<article>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#article09_11_16_1626218</id>
	<title>If the Comments Are Ugly, the Code Is Ugly</title>
	<author>CmdrTaco</author>
	<datestamp>1258388940000</datestamp>
	<htmltext>itwbennett writes <i>"What do your comments say about your code? Do <a href="http://www.itworld.com/development/84780/if-comments-are-ugly-code-ugly">grammatical errors in comments</a> point to even bigger errors in code? That's what Esther Schindler contends in a recent blog post. 'Programming, whether you're doing it as an open source enthusiast or because you're workin' for The Man, is an exercise in attention to detail,' says Schindler. 'Someone who writes software must be a nit-picker, or the code won't work ... Long-winded 'explanations' of the code in the application's comments (that is, the ones that read like excuses) indicate that the developer probably didn't understand what he was doing.'"</i></htmltext>
<tokenext>itwbennett writes " What do your comments say about your code ?
Do grammatical errors in comments point to even bigger errors in code ?
That 's what Esther Schindler contends in a recent blog post .
'Programming , whether you 're doing it as an open source enthusiast or because you 're workin ' for The Man , is an exercise in attention to detail, ' says Schindler .
'Someone who writes software must be a nit-picker , or the code wo n't work ... Long-winded 'explanations ' of the code in the application 's comments ( that is , the ones that read like excuses ) indicate that the developer probably did n't understand what he was doing .
' "</tokentext>
<sentencetext>itwbennett writes "What do your comments say about your code?
Do grammatical errors in comments point to even bigger errors in code?
That's what Esther Schindler contends in a recent blog post.
'Programming, whether you're doing it as an open source enthusiast or because you're workin' for The Man, is an exercise in attention to detail,' says Schindler.
'Someone who writes software must be a nit-picker, or the code won't work ... Long-winded 'explanations' of the code in the application's comments (that is, the ones that read like excuses) indicate that the developer probably didn't understand what he was doing.
'"</sentencetext>
</article>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120992</id>
	<title>Re:The comment may also be complex..</title>
	<author>cesutherland</author>
	<datestamp>1258364040000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>It also needs to be readable, comprehensible, and maintainable.</p></div><p>It needs to be elegant.</p></div>
	</htmltext>
<tokenext>It also needs to be readable , comprehensible , and maintainable.It needs to be elegant .</tokentext>
<sentencetext>It also needs to be readable, comprehensible, and maintainable.It needs to be elegant.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117028</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30133250</id>
	<title>Re:The comment may also be complex..</title>
	<author>Cederic</author>
	<datestamp>1258490160000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>Apparently there *is* a dark side to a high-quality unit test suite... it gives idiots a false sense of security and justifies their idiotic development practices.</p></div><p>Only where the test suite has been retrofitted to the code.</p><p>The mere act of testing as you develop changes your development methodology, your design approach, and the quality of your code.</p><p>Well, assuming you're doing it right of course. There's a whole new area of discussion..</p></div>
	</htmltext>
<tokenext>Apparently there * is * a dark side to a high-quality unit test suite... it gives idiots a false sense of security and justifies their idiotic development practices.Only where the test suite has been retrofitted to the code.The mere act of testing as you develop changes your development methodology , your design approach , and the quality of your code.Well , assuming you 're doing it right of course .
There 's a whole new area of discussion. .</tokentext>
<sentencetext>Apparently there *is* a dark side to a high-quality unit test suite... it gives idiots a false sense of security and justifies their idiotic development practices.Only where the test suite has been retrofitted to the code.The mere act of testing as you develop changes your development methodology, your design approach, and the quality of your code.Well, assuming you're doing it right of course.
There's a whole new area of discussion..
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117028</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118918</id>
	<title>I don't understand?</title>
	<author>Murdoch5</author>
	<datestamp>1258400400000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext>Wait so because I write comments my code is there for broke.   That's the most ridiculous thing I've ever heard.    If the code has spelling errors in it  could it be the the programming has bad spelling, or maybe bad grammer, which is turn would have nothing at all to do with there programming skill.  for instance.
<br>
<br>
<tt>
int main(void)
{<nobr> <wbr></nobr>//Prints helo world
                  printf("\nHello World");
}
</tt>
<br>
<br>
I put a spelling error in there on purpose, well the code would work fine.  What about being forced to leave comments for a prof to help explain the code.   I really can never see how ugly comments lead to ugly code.  Comments are a helpful feature of code if the programmer wants to put them in, they have no need to put them in and if the programmer doesn't want to they don't.put them in.
<br>
<br>
Complaining about the comments is like complaining about the indenting.   So because the Identing is done using space not tab the code is broken?  Of course not,   Any one who's going to complain about people not writing comments of anything outside of the code are just covering up for there own lack of programming skill.  Any real programmer will agree that comments are there for the programmer them selves to help them remember in a year or two if they go back to the code what they were thinking.
<br>
<br>
Weather the code is ugly or not has nothing to do with the code working, the code works or doesn't.  Past that the code is only rated based on memory and CPU use, thats it, not comments, not identing or anything else.</htmltext>
<tokenext>Wait so because I write comments my code is there for broke .
That 's the most ridiculous thing I 've ever heard .
If the code has spelling errors in it could it be the the programming has bad spelling , or maybe bad grammer , which is turn would have nothing at all to do with there programming skill .
for instance .
int main ( void ) { //Prints helo world printf ( " \ nHello World " ) ; } I put a spelling error in there on purpose , well the code would work fine .
What about being forced to leave comments for a prof to help explain the code .
I really can never see how ugly comments lead to ugly code .
Comments are a helpful feature of code if the programmer wants to put them in , they have no need to put them in and if the programmer does n't want to they do n't.put them in .
Complaining about the comments is like complaining about the indenting .
So because the Identing is done using space not tab the code is broken ?
Of course not , Any one who 's going to complain about people not writing comments of anything outside of the code are just covering up for there own lack of programming skill .
Any real programmer will agree that comments are there for the programmer them selves to help them remember in a year or two if they go back to the code what they were thinking .
Weather the code is ugly or not has nothing to do with the code working , the code works or does n't .
Past that the code is only rated based on memory and CPU use , thats it , not comments , not identing or anything else .</tokentext>
<sentencetext>Wait so because I write comments my code is there for broke.
That's the most ridiculous thing I've ever heard.
If the code has spelling errors in it  could it be the the programming has bad spelling, or maybe bad grammer, which is turn would have nothing at all to do with there programming skill.
for instance.
int main(void)
{ //Prints helo world
                  printf("\nHello World");
}



I put a spelling error in there on purpose, well the code would work fine.
What about being forced to leave comments for a prof to help explain the code.
I really can never see how ugly comments lead to ugly code.
Comments are a helpful feature of code if the programmer wants to put them in, they have no need to put them in and if the programmer doesn't want to they don't.put them in.
Complaining about the comments is like complaining about the indenting.
So because the Identing is done using space not tab the code is broken?
Of course not,   Any one who's going to complain about people not writing comments of anything outside of the code are just covering up for there own lack of programming skill.
Any real programmer will agree that comments are there for the programmer them selves to help them remember in a year or two if they go back to the code what they were thinking.
Weather the code is ugly or not has nothing to do with the code working, the code works or doesn't.
Past that the code is only rated based on memory and CPU use, thats it, not comments, not identing or anything else.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118668</id>
	<title>Re:The comment may also be complex..</title>
	<author>JD770</author>
	<datestamp>1258399620000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>I have found that the following old maxim holds true in the real world:
<br> <br>
Pick Two: Fast, Accurate, Cheap.
<br> <br>
I've found that clients understand that very well and will quite often toss not only thorough code commenting,  but in-depth documentation overboard if it will save money/time. But, that's their choice.
<br> <br>
If they want to include the extra time, I'll comment thoroughly and provide reams of documentation if desired. Other times, the client is only interested in rolling-out ASAP and I'm specifically told to minimize any and everything that could delay roll-out or exceed budget -- including comments and documentation. They are fully aware of the downside and accept it.
<br> <br>
It has been my experience that you have to be flexible. Excepting the laws of nature, there are no absolutes...</htmltext>
<tokenext>I have found that the following old maxim holds true in the real world : Pick Two : Fast , Accurate , Cheap .
I 've found that clients understand that very well and will quite often toss not only thorough code commenting , but in-depth documentation overboard if it will save money/time .
But , that 's their choice .
If they want to include the extra time , I 'll comment thoroughly and provide reams of documentation if desired .
Other times , the client is only interested in rolling-out ASAP and I 'm specifically told to minimize any and everything that could delay roll-out or exceed budget -- including comments and documentation .
They are fully aware of the downside and accept it .
It has been my experience that you have to be flexible .
Excepting the laws of nature , there are no absolutes.. .</tokentext>
<sentencetext>I have found that the following old maxim holds true in the real world:
 
Pick Two: Fast, Accurate, Cheap.
I've found that clients understand that very well and will quite often toss not only thorough code commenting,  but in-depth documentation overboard if it will save money/time.
But, that's their choice.
If they want to include the extra time, I'll comment thoroughly and provide reams of documentation if desired.
Other times, the client is only interested in rolling-out ASAP and I'm specifically told to minimize any and everything that could delay roll-out or exceed budget -- including comments and documentation.
They are fully aware of the downside and accept it.
It has been my experience that you have to be flexible.
Excepting the laws of nature, there are no absolutes...</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117026</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117320</id>
	<title>All code is crap</title>
	<author>lawman508</author>
	<datestamp>1258395600000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>Comments don't matter.
I've been coding for 25 years as a consultant for hundreds of companies.
All code is crap. The best you can hope for is to get home by 5:00 on Friday and do something that should really matter to you.

Can I create effecient, nicely structured code? Sure - and then some minimum wage programmer from 'Elbnonia' comes along the next day and mucks it up - with no accountability.


Do yourself a favor and accept these facts now - and you'll save yourself a lifetime of pain and disapointment.
If you want to create something of quality, which will last - become a musician or an artist or a poet - or better yet - go and volunteer at a homeless shelter or food bank.</htmltext>
<tokenext>Comments do n't matter .
I 've been coding for 25 years as a consultant for hundreds of companies .
All code is crap .
The best you can hope for is to get home by 5 : 00 on Friday and do something that should really matter to you .
Can I create effecient , nicely structured code ?
Sure - and then some minimum wage programmer from 'Elbnonia ' comes along the next day and mucks it up - with no accountability .
Do yourself a favor and accept these facts now - and you 'll save yourself a lifetime of pain and disapointment .
If you want to create something of quality , which will last - become a musician or an artist or a poet - or better yet - go and volunteer at a homeless shelter or food bank .</tokentext>
<sentencetext>Comments don't matter.
I've been coding for 25 years as a consultant for hundreds of companies.
All code is crap.
The best you can hope for is to get home by 5:00 on Friday and do something that should really matter to you.
Can I create effecient, nicely structured code?
Sure - and then some minimum wage programmer from 'Elbnonia' comes along the next day and mucks it up - with no accountability.
Do yourself a favor and accept these facts now - and you'll save yourself a lifetime of pain and disapointment.
If you want to create something of quality, which will last - become a musician or an artist or a poet - or better yet - go and volunteer at a homeless shelter or food bank.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116874</id>
	<title>How much code is written by outsourcing?</title>
	<author>dejanc</author>
	<datestamp>1258393800000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>2</modscore>
	<htmltext>I work for a company in Serbia and we write code for an Italian corporation which also outsources their development to Brazil and India. I'm happy if comments are in English at all. Still, we get by just fine, as long as we agree on design patterns to use and writing clear and concise code.

Also, whatever happened to: "Comments should describe what the function is doing, not HOW it is doing it"?</htmltext>
<tokenext>I work for a company in Serbia and we write code for an Italian corporation which also outsources their development to Brazil and India .
I 'm happy if comments are in English at all .
Still , we get by just fine , as long as we agree on design patterns to use and writing clear and concise code .
Also , whatever happened to : " Comments should describe what the function is doing , not HOW it is doing it " ?</tokentext>
<sentencetext>I work for a company in Serbia and we write code for an Italian corporation which also outsources their development to Brazil and India.
I'm happy if comments are in English at all.
Still, we get by just fine, as long as we agree on design patterns to use and writing clear and concise code.
Also, whatever happened to: "Comments should describe what the function is doing, not HOW it is doing it"?</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118032</id>
	<title>So you are a good coder if you write short comment</title>
	<author>roguegramma</author>
	<datestamp>1258397700000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>So you are a good coder if you write short comments, like (?):<nobr> <wbr></nobr>//HACK !RG: code must work with decimals although it was never planned to.<br>hack();</p></htmltext>
<tokenext>So you are a good coder if you write short comments , like ( ?
) : //HACK ! RG : code must work with decimals although it was never planned to.hack ( ) ;</tokentext>
<sentencetext>So you are a good coder if you write short comments, like (?
): //HACK !RG: code must work with decimals although it was never planned to.hack();</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117344</id>
	<title>Re:Long-winded comments can be very useful</title>
	<author>pz</author>
	<datestamp>1258395720000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>I sometimes write code for number theory algorithms. Often short-cuts and little speed ups have long proofs to justify why they work. If I expect the code to be used/read by other people I'll often include these explanations (and so I don't need to bother convincing myself later if I look at the code a year later). There's nothing wrong with long comments. Moreover, given a negative attitude towards long comments, many bad programmers will likely simply respond by not commenting their code at all. That's not good.</p></div><p>I am similarly long-winded when I optimize code and end up using a particular, sometimes non-intuitive, phrasing because it ends up being faster.  I leave as much of the evidence and analysis in the comments as possible -- as the parent wrote, mostly so I don't need to convince myself again at a later time.  If there's a magic number, I provide the derivation of that number (e.g., explaining why 2 seconds is an appropriate timeout for a file transfer, and giving the empirical evidence).  Sometimes I'll even leave in commented out versions of the code that were particularly tempting, but that ultimately proved to be incorrect or slower.  But the MOST important version of these long-winded comments is when I'm going balls-to-the-wall for execution speed and the optimized code ends up being non-intuitive.  Then, I include the original source (that was previously shown to be correct) and any important intermediate stages in developing the final form, so that the optimized version can be validated.</p><p>Of course all of these different long-winded comments are important when the code itself is not clear, when there is substantial reasoning that was required to create the code, and when the code does not itself contain that reasoning at first inspection.  When writing high-quality code the first priority is correctness, and a very, very close second is clarity.</p></div>
	</htmltext>
<tokenext>I sometimes write code for number theory algorithms .
Often short-cuts and little speed ups have long proofs to justify why they work .
If I expect the code to be used/read by other people I 'll often include these explanations ( and so I do n't need to bother convincing myself later if I look at the code a year later ) .
There 's nothing wrong with long comments .
Moreover , given a negative attitude towards long comments , many bad programmers will likely simply respond by not commenting their code at all .
That 's not good.I am similarly long-winded when I optimize code and end up using a particular , sometimes non-intuitive , phrasing because it ends up being faster .
I leave as much of the evidence and analysis in the comments as possible -- as the parent wrote , mostly so I do n't need to convince myself again at a later time .
If there 's a magic number , I provide the derivation of that number ( e.g. , explaining why 2 seconds is an appropriate timeout for a file transfer , and giving the empirical evidence ) .
Sometimes I 'll even leave in commented out versions of the code that were particularly tempting , but that ultimately proved to be incorrect or slower .
But the MOST important version of these long-winded comments is when I 'm going balls-to-the-wall for execution speed and the optimized code ends up being non-intuitive .
Then , I include the original source ( that was previously shown to be correct ) and any important intermediate stages in developing the final form , so that the optimized version can be validated.Of course all of these different long-winded comments are important when the code itself is not clear , when there is substantial reasoning that was required to create the code , and when the code does not itself contain that reasoning at first inspection .
When writing high-quality code the first priority is correctness , and a very , very close second is clarity .</tokentext>
<sentencetext>I sometimes write code for number theory algorithms.
Often short-cuts and little speed ups have long proofs to justify why they work.
If I expect the code to be used/read by other people I'll often include these explanations (and so I don't need to bother convincing myself later if I look at the code a year later).
There's nothing wrong with long comments.
Moreover, given a negative attitude towards long comments, many bad programmers will likely simply respond by not commenting their code at all.
That's not good.I am similarly long-winded when I optimize code and end up using a particular, sometimes non-intuitive, phrasing because it ends up being faster.
I leave as much of the evidence and analysis in the comments as possible -- as the parent wrote, mostly so I don't need to convince myself again at a later time.
If there's a magic number, I provide the derivation of that number (e.g., explaining why 2 seconds is an appropriate timeout for a file transfer, and giving the empirical evidence).
Sometimes I'll even leave in commented out versions of the code that were particularly tempting, but that ultimately proved to be incorrect or slower.
But the MOST important version of these long-winded comments is when I'm going balls-to-the-wall for execution speed and the optimized code ends up being non-intuitive.
Then, I include the original source (that was previously shown to be correct) and any important intermediate stages in developing the final form, so that the optimized version can be validated.Of course all of these different long-winded comments are important when the code itself is not clear, when there is substantial reasoning that was required to create the code, and when the code does not itself contain that reasoning at first inspection.
When writing high-quality code the first priority is correctness, and a very, very close second is clarity.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116672</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121232</id>
	<title>I don't buy it</title>
	<author>ajs</author>
	<datestamp>1258365060000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Some of the finest code I've ever worked on was uncommented. Some of the worst code I've ever worked on had terse, but informative and readable comments.</p><p>This smells to me like someone who didn't work with very good code becoming aware of the fact that their initial assumptions about comments were incorrect. Sadly, they have yet to discover that their second round of assumptions is just as invalid.</p><p>If you ever want to browse through some solid code in order to get an understanding of what good code looks like, I suggest GCC. Just one example file (gcc/alias.c) starts with a comment on line 50 which continues to line 129, and I assure you that it's not there because the person who wrote it didn't understand what was going on.</p></htmltext>
<tokenext>Some of the finest code I 've ever worked on was uncommented .
Some of the worst code I 've ever worked on had terse , but informative and readable comments.This smells to me like someone who did n't work with very good code becoming aware of the fact that their initial assumptions about comments were incorrect .
Sadly , they have yet to discover that their second round of assumptions is just as invalid.If you ever want to browse through some solid code in order to get an understanding of what good code looks like , I suggest GCC .
Just one example file ( gcc/alias.c ) starts with a comment on line 50 which continues to line 129 , and I assure you that it 's not there because the person who wrote it did n't understand what was going on .</tokentext>
<sentencetext>Some of the finest code I've ever worked on was uncommented.
Some of the worst code I've ever worked on had terse, but informative and readable comments.This smells to me like someone who didn't work with very good code becoming aware of the fact that their initial assumptions about comments were incorrect.
Sadly, they have yet to discover that their second round of assumptions is just as invalid.If you ever want to browse through some solid code in order to get an understanding of what good code looks like, I suggest GCC.
Just one example file (gcc/alias.c) starts with a comment on line 50 which continues to line 129, and I assure you that it's not there because the person who wrote it didn't understand what was going on.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30119286</id>
	<title>Here is a sample of comment from my code :</title>
	<author>unity100</author>
	<datestamp>1258401360000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>###############<br>######## fUkc graNMar<br>###############</p></htmltext>
<tokenext># # # # # # # # # # # # # # # # # # # # # # # fUkc graNMar # # # # # # # # # # # # # # #</tokentext>
<sentencetext>####################### fUkc graNMar###############</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116884</id>
	<title>What if...</title>
	<author>Mr.Fork</author>
	<datestamp>1258393860000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>there are no comments?  I was once a programmer for EDS - I was responsible for the UNIX API that back-ended our helpdesk system.  It was mostly written in C.  The single biggest issue I had were the contractors who we brought in who either didn't comment on their function libraries they wrote, or their comments didn't follow proper function header commenting that you get if you went to school.<br> <br>The bottom line, if you don't have established code-commenting procedures and processes on how you code and a quality assurance process to ensure that code is written properly and documented, you get back what kind of 'box' you put around your programmers.  Those procedures are not suppose to limit how you put smarts into programming, but establish common programming language 'parameters' all programmers use on your team.  Beware of the contractor however, they tend to follow their own rules, and try to ensure their own self-worth by documenting poorly.</htmltext>
<tokenext>there are no comments ?
I was once a programmer for EDS - I was responsible for the UNIX API that back-ended our helpdesk system .
It was mostly written in C. The single biggest issue I had were the contractors who we brought in who either did n't comment on their function libraries they wrote , or their comments did n't follow proper function header commenting that you get if you went to school .
The bottom line , if you do n't have established code-commenting procedures and processes on how you code and a quality assurance process to ensure that code is written properly and documented , you get back what kind of 'box ' you put around your programmers .
Those procedures are not suppose to limit how you put smarts into programming , but establish common programming language 'parameters ' all programmers use on your team .
Beware of the contractor however , they tend to follow their own rules , and try to ensure their own self-worth by documenting poorly .</tokentext>
<sentencetext>there are no comments?
I was once a programmer for EDS - I was responsible for the UNIX API that back-ended our helpdesk system.
It was mostly written in C.  The single biggest issue I had were the contractors who we brought in who either didn't comment on their function libraries they wrote, or their comments didn't follow proper function header commenting that you get if you went to school.
The bottom line, if you don't have established code-commenting procedures and processes on how you code and a quality assurance process to ensure that code is written properly and documented, you get back what kind of 'box' you put around your programmers.
Those procedures are not suppose to limit how you put smarts into programming, but establish common programming language 'parameters' all programmers use on your team.
Beware of the contractor however, they tend to follow their own rules, and try to ensure their own self-worth by documenting poorly.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30123956</id>
	<title>Re:OT on long comments</title>
	<author>Anonymous</author>
	<datestamp>1258376700000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>&gt; As someone with good English skills<br><nobr> <wbr></nobr>...<br>&gt; and the particular necessray function that implements the solution</p><p>FAIL!</p></htmltext>
<tokenext>&gt; As someone with good English skills ... &gt; and the particular necessray function that implements the solutionFAIL !</tokentext>
<sentencetext>&gt; As someone with good English skills ...&gt; and the particular necessray function that implements the solutionFAIL!</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117144</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117692</id>
	<title>Re:Existence of Comments</title>
	<author>Anonymous</author>
	<datestamp>1258396620000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Not sure if you were being sarcastic, but in case you weren't, here's a protip: your code isn't as self-documenting as you think it is, and, even if it was, reading a paragraph of English is still an order of magnitude faster.  For the sakes of all of us who actually have to read other peoples' code, I wish the self-documenting myth would just die.</p></htmltext>
<tokenext>Not sure if you were being sarcastic , but in case you were n't , here 's a protip : your code is n't as self-documenting as you think it is , and , even if it was , reading a paragraph of English is still an order of magnitude faster .
For the sakes of all of us who actually have to read other peoples ' code , I wish the self-documenting myth would just die .</tokentext>
<sentencetext>Not sure if you were being sarcastic, but in case you weren't, here's a protip: your code isn't as self-documenting as you think it is, and, even if it was, reading a paragraph of English is still an order of magnitude faster.
For the sakes of all of us who actually have to read other peoples' code, I wish the self-documenting myth would just die.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116872</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117624</id>
	<title>Anonymous Coward</title>
	<author>Anonymous</author>
	<datestamp>1258396440000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Any kind of comments...even poor ones are better than nothing.  There is nothing more frustrating than having to pick through 2000 lines of code in a single method (inherited from someone) and try to decipher their "logic".  Even having poorly written comments can help lead you through their though process, and assist in identifying the problem.</p><p>However, not everyone who produces software is a grammatcial genius.  This is especially true of international developers having to put their comments in English for the American coroprations they work for.  I've known brilliant developers from all over the world whose code was solid, but whose comments left a lot to be desired...understandably.  I've never faulted anyone for attempting to make sense out of sometimes non-sensical processes.</p><p>This also doesn't take into account the frequent illogic steps "the business" want to put into software that developers have to compensate for.  How do you comment an exception to a rule that, itself, is an exception to another rule that is an addendum to a clarification?</p><p>Shennanigans I tells ya!</p></htmltext>
<tokenext>Any kind of comments...even poor ones are better than nothing .
There is nothing more frustrating than having to pick through 2000 lines of code in a single method ( inherited from someone ) and try to decipher their " logic " .
Even having poorly written comments can help lead you through their though process , and assist in identifying the problem.However , not everyone who produces software is a grammatcial genius .
This is especially true of international developers having to put their comments in English for the American coroprations they work for .
I 've known brilliant developers from all over the world whose code was solid , but whose comments left a lot to be desired...understandably .
I 've never faulted anyone for attempting to make sense out of sometimes non-sensical processes.This also does n't take into account the frequent illogic steps " the business " want to put into software that developers have to compensate for .
How do you comment an exception to a rule that , itself , is an exception to another rule that is an addendum to a clarification ? Shennanigans I tells ya !</tokentext>
<sentencetext>Any kind of comments...even poor ones are better than nothing.
There is nothing more frustrating than having to pick through 2000 lines of code in a single method (inherited from someone) and try to decipher their "logic".
Even having poorly written comments can help lead you through their though process, and assist in identifying the problem.However, not everyone who produces software is a grammatcial genius.
This is especially true of international developers having to put their comments in English for the American coroprations they work for.
I've known brilliant developers from all over the world whose code was solid, but whose comments left a lot to be desired...understandably.
I've never faulted anyone for attempting to make sense out of sometimes non-sensical processes.This also doesn't take into account the frequent illogic steps "the business" want to put into software that developers have to compensate for.
How do you comment an exception to a rule that, itself, is an exception to another rule that is an addendum to a clarification?Shennanigans I tells ya!</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118834</id>
	<title>Commenting Practices</title>
	<author>PerfectionLost</author>
	<datestamp>1258400100000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>A short description never hurt anyone.

</p><p>I also find that if I am writing complicated code I like to write all the comments beforehand, and then fill in the specific jargon afterwords.

</p><p>//Loop over every item.

</p><p>//Preform some menial data manipulation if this is an existing item

</p><p>//Do a nested loop if necessary

</p><p>//Finish looping over items.

</p><p>//Commit data.

</p><p>It's like writing an outline before you write the story, which I find really useful in fiction as well.  That way you know where you are going in the end.</p></htmltext>
<tokenext>A short description never hurt anyone .
I also find that if I am writing complicated code I like to write all the comments beforehand , and then fill in the specific jargon afterwords .
//Loop over every item .
//Preform some menial data manipulation if this is an existing item //Do a nested loop if necessary //Finish looping over items .
//Commit data .
It 's like writing an outline before you write the story , which I find really useful in fiction as well .
That way you know where you are going in the end .</tokentext>
<sentencetext>A short description never hurt anyone.
I also find that if I am writing complicated code I like to write all the comments beforehand, and then fill in the specific jargon afterwords.
//Loop over every item.
//Preform some menial data manipulation if this is an existing item

//Do a nested loop if necessary

//Finish looping over items.
//Commit data.
It's like writing an outline before you write the story, which I find really useful in fiction as well.
That way you know where you are going in the end.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117430</id>
	<title>Commenting, Like programming is an Art</title>
	<author>AxDx</author>
	<datestamp>1258395960000</datestamp>
	<modclass>Informativ</modclass>
	<modscore>2</modscore>
	<htmltext>Commenting well in a program can be the difference between hours of backtracking, reverse engineering, and other wastes of time.  Even if the original programmer is the only one who will ever see them, good comments are just as important as good code.  I don't know about you guys, but I find myself having to go back to something I did months and even years ago. Comments make the total difference between a quick add-on/fix or hours of hair pulling frustration.  Learn to Code, then learn to comment.  That combo is unstoppable</htmltext>
<tokenext>Commenting well in a program can be the difference between hours of backtracking , reverse engineering , and other wastes of time .
Even if the original programmer is the only one who will ever see them , good comments are just as important as good code .
I do n't know about you guys , but I find myself having to go back to something I did months and even years ago .
Comments make the total difference between a quick add-on/fix or hours of hair pulling frustration .
Learn to Code , then learn to comment .
That combo is unstoppable</tokentext>
<sentencetext>Commenting well in a program can be the difference between hours of backtracking, reverse engineering, and other wastes of time.
Even if the original programmer is the only one who will ever see them, good comments are just as important as good code.
I don't know about you guys, but I find myself having to go back to something I did months and even years ago.
Comments make the total difference between a quick add-on/fix or hours of hair pulling frustration.
Learn to Code, then learn to comment.
That combo is unstoppable</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117648</id>
	<title>Re:I agree, with reservations</title>
	<author>NoYob</author>
	<datestamp>1258396500000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>2</modscore>
	<htmltext><p><div class="quote"><p>From 30 years of developing software, I've found time and time again that it actually does seem that people who don't know or care about the difference between "their" and "they're" are also too sloppy, unintelligent or just not anal enough to write clean, supportable and robust code.</p><p>However I feel we do need to make more allowance than the article's author did for people who did not learn English as a first language.</p></div><p>I'm impressed - 30 years! Wow!</p><p>In my measly 15 years of experience, I've had to spend many long hours meeting deadlines that some salesman made for us to make the sale. Of course, management backed up the ridiculous deadline because "if the salesman didn't say it could be done, some other company would have and we wouldn't have had the business!' So, said salesman makes his 6 figure commission and us coders are working 80+ hours a week to meet the ridiculous deadline - which happens frequently. Now, when I'm tired, fearing for my job, and trying to design and code on top of all that, the last thing I'm worried about is making sure I don't confuse "they're" with "their" or with "there". I'm worried about being productive, because if I'm not, they'll send the work to a country where they don't even speak English; let alone actually even bother to comment their code.</p><p>Personally, I'd rather have something than nothing; regardless of how poor the spelling is or the grammar. It's a software comment, not a dissertation. </p><p> But that's been my measly newbie experience.</p></div>
	</htmltext>
<tokenext>From 30 years of developing software , I 've found time and time again that it actually does seem that people who do n't know or care about the difference between " their " and " they 're " are also too sloppy , unintelligent or just not anal enough to write clean , supportable and robust code.However I feel we do need to make more allowance than the article 's author did for people who did not learn English as a first language.I 'm impressed - 30 years !
Wow ! In my measly 15 years of experience , I 've had to spend many long hours meeting deadlines that some salesman made for us to make the sale .
Of course , management backed up the ridiculous deadline because " if the salesman did n't say it could be done , some other company would have and we would n't have had the business !
' So , said salesman makes his 6 figure commission and us coders are working 80 + hours a week to meet the ridiculous deadline - which happens frequently .
Now , when I 'm tired , fearing for my job , and trying to design and code on top of all that , the last thing I 'm worried about is making sure I do n't confuse " they 're " with " their " or with " there " .
I 'm worried about being productive , because if I 'm not , they 'll send the work to a country where they do n't even speak English ; let alone actually even bother to comment their code.Personally , I 'd rather have something than nothing ; regardless of how poor the spelling is or the grammar .
It 's a software comment , not a dissertation .
But that 's been my measly newbie experience .</tokentext>
<sentencetext>From 30 years of developing software, I've found time and time again that it actually does seem that people who don't know or care about the difference between "their" and "they're" are also too sloppy, unintelligent or just not anal enough to write clean, supportable and robust code.However I feel we do need to make more allowance than the article's author did for people who did not learn English as a first language.I'm impressed - 30 years!
Wow!In my measly 15 years of experience, I've had to spend many long hours meeting deadlines that some salesman made for us to make the sale.
Of course, management backed up the ridiculous deadline because "if the salesman didn't say it could be done, some other company would have and we wouldn't have had the business!
' So, said salesman makes his 6 figure commission and us coders are working 80+ hours a week to meet the ridiculous deadline - which happens frequently.
Now, when I'm tired, fearing for my job, and trying to design and code on top of all that, the last thing I'm worried about is making sure I don't confuse "they're" with "their" or with "there".
I'm worried about being productive, because if I'm not, they'll send the work to a country where they don't even speak English; let alone actually even bother to comment their code.Personally, I'd rather have something than nothing; regardless of how poor the spelling is or the grammar.
It's a software comment, not a dissertation.
But that's been my measly newbie experience.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116868</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117122</id>
	<title>Re:10 PRIN "WTF"</title>
	<author>dkh2</author>
	<datestamp>1258394820000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>The classic is a block of select\_case logic with no default.  The developer is given a static list of current cases for which results are calculable. Yet, they #FAIL to consider that the case list may be not as finite and immutable as presumed. When a new case is presented then code without a default response will fail.</p></htmltext>
<tokenext>The classic is a block of select \ _case logic with no default .
The developer is given a static list of current cases for which results are calculable .
Yet , they # FAIL to consider that the case list may be not as finite and immutable as presumed .
When a new case is presented then code without a default response will fail .</tokentext>
<sentencetext>The classic is a block of select\_case logic with no default.
The developer is given a static list of current cases for which results are calculable.
Yet, they #FAIL to consider that the case list may be not as finite and immutable as presumed.
When a new case is presented then code without a default response will fail.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116716</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118764</id>
	<title>Re:OT on long comments</title>
	<author>Anonymous</author>
	<datestamp>1258399920000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Gah, your comment was too long to read.</p></htmltext>
<tokenext>Gah , your comment was too long to read .</tokentext>
<sentencetext>Gah, your comment was too long to read.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117144</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116732</id>
	<title>I'd rather...</title>
	<author>Purist</author>
	<datestamp>1258393440000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext>...see somewhat verbose comments than none at all.  However, a good developer should be able to provide very clear and concise comments and let the code say the rest.  I think this is what the original post's point is - of the code is not concise and clear, the comments won't be either.

P</htmltext>
<tokenext>...see somewhat verbose comments than none at all .
However , a good developer should be able to provide very clear and concise comments and let the code say the rest .
I think this is what the original post 's point is - of the code is not concise and clear , the comments wo n't be either .
P</tokentext>
<sentencetext>...see somewhat verbose comments than none at all.
However, a good developer should be able to provide very clear and concise comments and let the code say the rest.
I think this is what the original post's point is - of the code is not concise and clear, the comments won't be either.
P</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120190</id>
	<title>What utter poppycock</title>
	<author>wb8wsf</author>
	<datestamp>1258404240000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>   Comments are a skill in and of themselves, which a whole lot of people never master.</p><p>
&nbsp; &nbsp; &nbsp; I remember two people who worked at a place where I was programming.  The first<br>was a woman, freshly out of school who was taught that comments made the code.<br>So she dutifully wrote beautiful comments on the theory of what the function was<br>going to do, but also inline, especially for arcane things going on in an algorithm.  All<br>nicely spaced, neat.  A marvel to behold.  Problem was, the code this person did<br>had some form of overflow condition (this was C) about every five lines, such that<br>I knew if I poked at the code from a higher layer I could cause problems.  And did,<br>because I was trying to force the issue and have some kind of review go on.</p><p>
&nbsp; &nbsp; &nbsp; The other person in the larger group was a 20ish male, who saw human interaction<br>largely through the eyes of TV, and gaming / nerd get-togethers.  Hardly a bad person,<br>he just didn't seem to have humans around him when growing up (more than a trifle<br>odd, even now--I met him again for the first time in 20 years; the only change was<br>gray hair).  He was one of the people I'd go to for help when I botched things, or<br>wanted comments on an idea I had.  His code often worked the first time run, and<br>I'm not talking of little 10 line routines, but larger complex functions.  His comments<br>were about the opposite of the code, both in terms of spelling, grammar, and that<br>ephemeral concept of how to communicate in general.  Some sentences were<br>better read thinking of them as RPN, and others simply defied standard logic.<br>Comments that did survive that minimal test of English were often spelled in<br>novel ways, causing euqal parts of head scratching and laughter.  But the code<br>was great!</p><p>I offer these two examples which while extremes, are examples that poke holes<br>in the idea that there is a common relationship between comments and code.<br>Certainly some people will fit that mold, but I think that more random than not.</p></htmltext>
<tokenext>Comments are a skill in and of themselves , which a whole lot of people never master .
      I remember two people who worked at a place where I was programming .
The firstwas a woman , freshly out of school who was taught that comments made the code.So she dutifully wrote beautiful comments on the theory of what the function wasgoing to do , but also inline , especially for arcane things going on in an algorithm .
Allnicely spaced , neat .
A marvel to behold .
Problem was , the code this person didhad some form of overflow condition ( this was C ) about every five lines , such thatI knew if I poked at the code from a higher layer I could cause problems .
And did,because I was trying to force the issue and have some kind of review go on .
      The other person in the larger group was a 20ish male , who saw human interactionlargely through the eyes of TV , and gaming / nerd get-togethers .
Hardly a bad person,he just did n't seem to have humans around him when growing up ( more than a trifleodd , even now--I met him again for the first time in 20 years ; the only change wasgray hair ) .
He was one of the people I 'd go to for help when I botched things , orwanted comments on an idea I had .
His code often worked the first time run , andI 'm not talking of little 10 line routines , but larger complex functions .
His commentswere about the opposite of the code , both in terms of spelling , grammar , and thatephemeral concept of how to communicate in general .
Some sentences werebetter read thinking of them as RPN , and others simply defied standard logic.Comments that did survive that minimal test of English were often spelled innovel ways , causing euqal parts of head scratching and laughter .
But the codewas great ! I offer these two examples which while extremes , are examples that poke holesin the idea that there is a common relationship between comments and code.Certainly some people will fit that mold , but I think that more random than not .</tokentext>
<sentencetext>   Comments are a skill in and of themselves, which a whole lot of people never master.
      I remember two people who worked at a place where I was programming.
The firstwas a woman, freshly out of school who was taught that comments made the code.So she dutifully wrote beautiful comments on the theory of what the function wasgoing to do, but also inline, especially for arcane things going on in an algorithm.
Allnicely spaced, neat.
A marvel to behold.
Problem was, the code this person didhad some form of overflow condition (this was C) about every five lines, such thatI knew if I poked at the code from a higher layer I could cause problems.
And did,because I was trying to force the issue and have some kind of review go on.
      The other person in the larger group was a 20ish male, who saw human interactionlargely through the eyes of TV, and gaming / nerd get-togethers.
Hardly a bad person,he just didn't seem to have humans around him when growing up (more than a trifleodd, even now--I met him again for the first time in 20 years; the only change wasgray hair).
He was one of the people I'd go to for help when I botched things, orwanted comments on an idea I had.
His code often worked the first time run, andI'm not talking of little 10 line routines, but larger complex functions.
His commentswere about the opposite of the code, both in terms of spelling, grammar, and thatephemeral concept of how to communicate in general.
Some sentences werebetter read thinking of them as RPN, and others simply defied standard logic.Comments that did survive that minimal test of English were often spelled innovel ways, causing euqal parts of head scratching and laughter.
But the codewas great!I offer these two examples which while extremes, are examples that poke holesin the idea that there is a common relationship between comments and code.Certainly some people will fit that mold, but I think that more random than not.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118868</id>
	<title>Re:I agree, with reservations</title>
	<author>Anonymous</author>
	<datestamp>1258400220000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>It seems most of these people live in a different universe than the<br>one I worked in before I retired. Estimates were continually undercut,<br>workload added, features tacked on; fundamental changes to requirements<br>appeared with great regularity. All of these things with no allowance for<br>the added time required. Is it any wonder that comments get pushed aside or<br>even ignored. Yes, well written code is wonderful. Yes, good comments helps<br>to make any code easier to understand (read BETTER). However do not<br>be surprised when circumstances make it difficult to create such wonders.</p></htmltext>
<tokenext>It seems most of these people live in a different universe than theone I worked in before I retired .
Estimates were continually undercut,workload added , features tacked on ; fundamental changes to requirementsappeared with great regularity .
All of these things with no allowance forthe added time required .
Is it any wonder that comments get pushed aside oreven ignored .
Yes , well written code is wonderful .
Yes , good comments helpsto make any code easier to understand ( read BETTER ) .
However do notbe surprised when circumstances make it difficult to create such wonders .</tokentext>
<sentencetext>It seems most of these people live in a different universe than theone I worked in before I retired.
Estimates were continually undercut,workload added, features tacked on; fundamental changes to requirementsappeared with great regularity.
All of these things with no allowance forthe added time required.
Is it any wonder that comments get pushed aside oreven ignored.
Yes, well written code is wonderful.
Yes, good comments helpsto make any code easier to understand (read BETTER).
However do notbe surprised when circumstances make it difficult to create such wonders.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116868</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117654</id>
	<title>Re:Well, duh.</title>
	<author>tgrigsby</author>
	<datestamp>1258396500000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>2</modscore>
	<htmltext><p><i>&gt;&gt; That's also why I don't comment my code.</i></p><p><i>This is a good practice. Comments very seldom keep up with changes in the code base, so more often than not, they end up being misleading at some point in the future.</i></p><p>That's complete crap.  I've heard this argument before, that by not putting in comments you force the next guy to read all the code.  That of course assumes that your code is so clean, obvious, and readable that the next guy will be smitten with your mad skillz.</p><p>I would say that it's a reliable indication of extreme ego and lack of skills when a programmer eschews comments entirely.</p><p>Comments serve as an aid to understand not only the code but the problem domain addressed by the code. It's a means of recording knowledge that the code doesn't make readily apparent.  Reticence to comment indicates laziness and perhaps even a lack of understanding as to why the code worked in the first place.</p></htmltext>
<tokenext>&gt; &gt; That 's also why I do n't comment my code.This is a good practice .
Comments very seldom keep up with changes in the code base , so more often than not , they end up being misleading at some point in the future.That 's complete crap .
I 've heard this argument before , that by not putting in comments you force the next guy to read all the code .
That of course assumes that your code is so clean , obvious , and readable that the next guy will be smitten with your mad skillz.I would say that it 's a reliable indication of extreme ego and lack of skills when a programmer eschews comments entirely.Comments serve as an aid to understand not only the code but the problem domain addressed by the code .
It 's a means of recording knowledge that the code does n't make readily apparent .
Reticence to comment indicates laziness and perhaps even a lack of understanding as to why the code worked in the first place .</tokentext>
<sentencetext>&gt;&gt; That's also why I don't comment my code.This is a good practice.
Comments very seldom keep up with changes in the code base, so more often than not, they end up being misleading at some point in the future.That's complete crap.
I've heard this argument before, that by not putting in comments you force the next guy to read all the code.
That of course assumes that your code is so clean, obvious, and readable that the next guy will be smitten with your mad skillz.I would say that it's a reliable indication of extreme ego and lack of skills when a programmer eschews comments entirely.Comments serve as an aid to understand not only the code but the problem domain addressed by the code.
It's a means of recording knowledge that the code doesn't make readily apparent.
Reticence to comment indicates laziness and perhaps even a lack of understanding as to why the code worked in the first place.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116970</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30128270</id>
	<title>Re:I agree, with reservations</title>
	<author>rackeer</author>
	<datestamp>1258470060000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>That's probably true for all areas, not just programming (although you should make allowances for dyslexic and so on). This is also mentioned in TFA. The original article is BTW <a href="http://www.dadhacker.com/blog/?p=1132" title="dadhacker.com" rel="nofollow">30 years of C</a> [dadhacker.com]. It's actually only a paragraph there: <br>

<i>2. Good programs do not contain spelling errors or have grammatical mistakes. I think this is probably a result of fractal attention to detail; in great programs things are correct at all levels, down to the periods at the ends of sentences in comments.<br>

&ldquo;Aw, c&rsquo;mon! You&rsquo;re kidding!&rdquo; You might think that nit-picking like this is beneath you, whereupon I will start pointing out errors in your code. It was embarrassing the first couple times this happened to me.</i> <br>

I think this categorical statement ("does not contain") is a bit harsh, but there's certainly a relationship between clear thinking in language and style and the quality of content (the code).</htmltext>
<tokenext>That 's probably true for all areas , not just programming ( although you should make allowances for dyslexic and so on ) .
This is also mentioned in TFA .
The original article is BTW 30 years of C [ dadhacker.com ] .
It 's actually only a paragraph there : 2 .
Good programs do not contain spelling errors or have grammatical mistakes .
I think this is probably a result of fractal attention to detail ; in great programs things are correct at all levels , down to the periods at the ends of sentences in comments .
   Aw , c    mon !
You    re kidding !    You might think that nit-picking like this is beneath you , whereupon I will start pointing out errors in your code .
It was embarrassing the first couple times this happened to me .
I think this categorical statement ( " does not contain " ) is a bit harsh , but there 's certainly a relationship between clear thinking in language and style and the quality of content ( the code ) .</tokentext>
<sentencetext>That's probably true for all areas, not just programming (although you should make allowances for dyslexic and so on).
This is also mentioned in TFA.
The original article is BTW 30 years of C [dadhacker.com].
It's actually only a paragraph there: 

2.
Good programs do not contain spelling errors or have grammatical mistakes.
I think this is probably a result of fractal attention to detail; in great programs things are correct at all levels, down to the periods at the ends of sentences in comments.
“Aw, c’mon!
You’re kidding!” You might think that nit-picking like this is beneath you, whereupon I will start pointing out errors in your code.
It was embarrassing the first couple times this happened to me.
I think this categorical statement ("does not contain") is a bit harsh, but there's certainly a relationship between clear thinking in language and style and the quality of content (the code).</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116868</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116756</id>
	<title>Bad spelling too often = bad thinking</title>
	<author>gestalt\_n\_pepper</author>
	<datestamp>1258393440000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Or at least sloppy thinking. I have no idea why this is, but as anyone who has looked at internet blogs can attest, the people who can't be bothered with proper spelling, grammar, punctuation or capitalization, or who can't differentiate between "loose" and "lose" are also (usually) the biggest idiots.</p></htmltext>
<tokenext>Or at least sloppy thinking .
I have no idea why this is , but as anyone who has looked at internet blogs can attest , the people who ca n't be bothered with proper spelling , grammar , punctuation or capitalization , or who ca n't differentiate between " loose " and " lose " are also ( usually ) the biggest idiots .</tokentext>
<sentencetext>Or at least sloppy thinking.
I have no idea why this is, but as anyone who has looked at internet blogs can attest, the people who can't be bothered with proper spelling, grammar, punctuation or capitalization, or who can't differentiate between "loose" and "lose" are also (usually) the biggest idiots.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118696</id>
	<title>Show me the code because I don't buy it.</title>
	<author>tomhudson</author>
	<datestamp>1258399680000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>
FTFA:</p><blockquote><div><p>Surely, you don't need me to cite the number of <b>famous programming failures</b> that were the result of a developer using a comma instead of a period</p></div>
</blockquote><p>
If it's c++, it probably wouldn't compile, so it would get fixed, so yes, I need you to cite <b>famous programming errors</b> where that happened, because I don't buy it. Links or it didn't happen.
</p><p>
Remember - <b>famous</b>. Not trivial "example code".
</p></div>
	</htmltext>
<tokenext>FTFA : Surely , you do n't need me to cite the number of famous programming failures that were the result of a developer using a comma instead of a period If it 's c + + , it probably would n't compile , so it would get fixed , so yes , I need you to cite famous programming errors where that happened , because I do n't buy it .
Links or it did n't happen .
Remember - famous .
Not trivial " example code " .</tokentext>
<sentencetext>
FTFA:Surely, you don't need me to cite the number of famous programming failures that were the result of a developer using a comma instead of a period

If it's c++, it probably wouldn't compile, so it would get fixed, so yes, I need you to cite famous programming errors where that happened, because I don't buy it.
Links or it didn't happen.
Remember - famous.
Not trivial "example code".

	</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121306</id>
	<title>Re:The comment may also be complex..</title>
	<author>Sandbags</author>
	<datestamp>1258365300000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I used to be the opposite. We had a professor who did nothing but try to throw BAD data at good code to see if he could break it.  Extreme levels of code validation....</p><p>I wrote all kinds of software to TRACK such attemtps (including cross assignment/project), and would do crazy stuff to him and his computer when he kept failing to actually find holes in my test scenarios...</p><p>I had simple programs that could have been a few dozen pages of basic commented code otherwise, but they'de be nearly 100 pages of code by the time I tacked in all the other crap to mess with him<nobr> <wbr></nobr>:)</p><p>I had a seperate proffessor who graded code projects as much on good code commentiung and formatting as he did on code execution.  If it compiled, and ran his test data set, you got a 50\%...  the other 50\% was all in how it looked on paper!</p><p>Rule fo thumb:  Every line needs both a coment and a debug line.  Every function or code loopp/process needs a header description.  every subprogram should have an inline manual.  Any entry should be able to accept a null input (or a ? or something), and output to a user the correct input (ie, if you fail to give it the right format, it shoudl automatically prompt/repromt including help lines to get it from you).</p><p>Give me 100 lines of good readible raw code, and I'll give you back 300-400 lines of formatted, commented code that would get an A in his class.</p></htmltext>
<tokenext>I used to be the opposite .
We had a professor who did nothing but try to throw BAD data at good code to see if he could break it .
Extreme levels of code validation....I wrote all kinds of software to TRACK such attemtps ( including cross assignment/project ) , and would do crazy stuff to him and his computer when he kept failing to actually find holes in my test scenarios...I had simple programs that could have been a few dozen pages of basic commented code otherwise , but they'de be nearly 100 pages of code by the time I tacked in all the other crap to mess with him : ) I had a seperate proffessor who graded code projects as much on good code commentiung and formatting as he did on code execution .
If it compiled , and ran his test data set , you got a 50 \ % ... the other 50 \ % was all in how it looked on paper ! Rule fo thumb : Every line needs both a coment and a debug line .
Every function or code loopp/process needs a header description .
every subprogram should have an inline manual .
Any entry should be able to accept a null input ( or a ?
or something ) , and output to a user the correct input ( ie , if you fail to give it the right format , it shoudl automatically prompt/repromt including help lines to get it from you ) .Give me 100 lines of good readible raw code , and I 'll give you back 300-400 lines of formatted , commented code that would get an A in his class .</tokentext>
<sentencetext>I used to be the opposite.
We had a professor who did nothing but try to throw BAD data at good code to see if he could break it.
Extreme levels of code validation....I wrote all kinds of software to TRACK such attemtps (including cross assignment/project), and would do crazy stuff to him and his computer when he kept failing to actually find holes in my test scenarios...I had simple programs that could have been a few dozen pages of basic commented code otherwise, but they'de be nearly 100 pages of code by the time I tacked in all the other crap to mess with him :)I had a seperate proffessor who graded code projects as much on good code commentiung and formatting as he did on code execution.
If it compiled, and ran his test data set, you got a 50\%...  the other 50\% was all in how it looked on paper!Rule fo thumb:  Every line needs both a coment and a debug line.
Every function or code loopp/process needs a header description.
every subprogram should have an inline manual.
Any entry should be able to accept a null input (or a ?
or something), and output to a user the correct input (ie, if you fail to give it the right format, it shoudl automatically prompt/repromt including help lines to get it from you).Give me 100 lines of good readible raw code, and I'll give you back 300-400 lines of formatted, commented code that would get an A in his class.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117028</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30123504</id>
	<title>Re:Existence of Comments</title>
	<author>Lord Ender</author>
	<datestamp>1258374060000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><blockquote><div><p>(Any good Perl programmer knows this.)</p></div></blockquote><p>Therefore, there exists no person X such that X knows this. QED.</p></div>
	</htmltext>
<tokenext>( Any good Perl programmer knows this .
) Therefore , there exists no person X such that X knows this .
QED .</tokentext>
<sentencetext>(Any good Perl programmer knows this.
)Therefore, there exists no person X such that X knows this.
QED.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116872</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121316</id>
	<title>Re:You are not expected to understand this</title>
	<author>syousef</author>
	<datestamp>1258365360000</datestamp>
	<modclass>Informativ</modclass>
	<modscore>2</modscore>
	<htmltext><p><i>So here's an example of a comment that does an excellent (I assume) job of explaining why the code is doing what it's doing, yet the whole thing is so complicated that Ritchie even needed to acknowledge that the comment probably wasn't going to be of much help either with an amusing, and now somewhat famous, statement.</i></p><p>Sorry but that is just a piss poor comment and there is no excuse for glorifying it. If it's that complex, he needs to refer back to a particular section of a particular version of a design document. If there is no design document one needs to be written. There are times when what you're doing is so complex that the only sane option is to refer to more extensive documentation rather than try to explain it inline. That is not an excuse for a supposedly witty cryptic comment.</p></htmltext>
<tokenext>So here 's an example of a comment that does an excellent ( I assume ) job of explaining why the code is doing what it 's doing , yet the whole thing is so complicated that Ritchie even needed to acknowledge that the comment probably was n't going to be of much help either with an amusing , and now somewhat famous , statement.Sorry but that is just a piss poor comment and there is no excuse for glorifying it .
If it 's that complex , he needs to refer back to a particular section of a particular version of a design document .
If there is no design document one needs to be written .
There are times when what you 're doing is so complex that the only sane option is to refer to more extensive documentation rather than try to explain it inline .
That is not an excuse for a supposedly witty cryptic comment .</tokentext>
<sentencetext>So here's an example of a comment that does an excellent (I assume) job of explaining why the code is doing what it's doing, yet the whole thing is so complicated that Ritchie even needed to acknowledge that the comment probably wasn't going to be of much help either with an amusing, and now somewhat famous, statement.Sorry but that is just a piss poor comment and there is no excuse for glorifying it.
If it's that complex, he needs to refer back to a particular section of a particular version of a design document.
If there is no design document one needs to be written.
There are times when what you're doing is so complex that the only sane option is to refer to more extensive documentation rather than try to explain it inline.
That is not an excuse for a supposedly witty cryptic comment.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117090</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120902</id>
	<title>Cody Ugly</title>
	<author>carrier lost</author>
	<datestamp>1258363680000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I sometimes comment my code in excruciating detail.  But that's when what I've done was so hard to figure out in the first place, I want to make sure that whoever comes after me or if I have to revisit it again, there's some explanation as to what the hell's going on.</p></htmltext>
<tokenext>I sometimes comment my code in excruciating detail .
But that 's when what I 've done was so hard to figure out in the first place , I want to make sure that whoever comes after me or if I have to revisit it again , there 's some explanation as to what the hell 's going on .</tokentext>
<sentencetext>I sometimes comment my code in excruciating detail.
But that's when what I've done was so hard to figure out in the first place, I want to make sure that whoever comes after me or if I have to revisit it again, there's some explanation as to what the hell's going on.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30124716</id>
	<title>Let me see if I understand...</title>
	<author>Anonymous</author>
	<datestamp>1258381860000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>So what your saying is if I don't comment my code at all, then by definition it must be genius?</p></htmltext>
<tokenext>So what your saying is if I do n't comment my code at all , then by definition it must be genius ?</tokentext>
<sentencetext>So what your saying is if I don't comment my code at all, then by definition it must be genius?</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118418</id>
	<title>Re:Existence of Comments</title>
	<author>Anonymous</author>
	<datestamp>1258398720000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p><div class="quote"><p>If comments even exist, then the code is ugly.  Code should document itself.


(Any good Perl programmer knows this.)</p></div><p>This from a language with functions like chomp()  *eyeroll*</p></div>
	</htmltext>
<tokenext>If comments even exist , then the code is ugly .
Code should document itself .
( Any good Perl programmer knows this .
) This from a language with functions like chomp ( ) * eyeroll *</tokentext>
<sentencetext>If comments even exist, then the code is ugly.
Code should document itself.
(Any good Perl programmer knows this.
)This from a language with functions like chomp()  *eyeroll*
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116872</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116558</id>
	<title>The comment may also be complex..</title>
	<author>Anonymous</author>
	<datestamp>1258392780000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>5</modscore>
	<htmltext>An explanation may be long if it is explaining something complex that the code is doing.  A long-winded comment may also be a precise one, rather than a general one: rather than an excuse, this may be an explanation.</htmltext>
<tokenext>An explanation may be long if it is explaining something complex that the code is doing .
A long-winded comment may also be a precise one , rather than a general one : rather than an excuse , this may be an explanation .</tokentext>
<sentencetext>An explanation may be long if it is explaining something complex that the code is doing.
A long-winded comment may also be a precise one, rather than a general one: rather than an excuse, this may be an explanation.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118498</id>
	<title>syntactic and logical perfection can be crap</title>
	<author>Anonymous</author>
	<datestamp>1258399020000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>4</modscore>
	<htmltext><p>Perfectly working, syntactically and logically correct code can be utter crap if it is not maintainable.</p><p>Years ago, a very smart man told me that I was not writing code for the compiler, I was writing code for the next poor slob that had to work on it.  Let's face it, most source code is going to be subject to rework or maintenance over its life span, so let's do what we can to make that next developer productive.  The key to this is reasonable commenting.</p><p>One of the best ways I know of to teach developers to write maintainable code is to have them do support and maintenance for a while.  Developers learn quickly which styles work for maintenance, and which ones don't.</p><p>As far as I am concerned, source code needs to look good as well as compile.  So I would go one step beyond TFA to say that style, indentation, proper symbol names, use of constants where appropriate, and (yes) proper commenting are all good indicators of quality in source code.</p></htmltext>
<tokenext>Perfectly working , syntactically and logically correct code can be utter crap if it is not maintainable.Years ago , a very smart man told me that I was not writing code for the compiler , I was writing code for the next poor slob that had to work on it .
Let 's face it , most source code is going to be subject to rework or maintenance over its life span , so let 's do what we can to make that next developer productive .
The key to this is reasonable commenting.One of the best ways I know of to teach developers to write maintainable code is to have them do support and maintenance for a while .
Developers learn quickly which styles work for maintenance , and which ones do n't.As far as I am concerned , source code needs to look good as well as compile .
So I would go one step beyond TFA to say that style , indentation , proper symbol names , use of constants where appropriate , and ( yes ) proper commenting are all good indicators of quality in source code .</tokentext>
<sentencetext>Perfectly working, syntactically and logically correct code can be utter crap if it is not maintainable.Years ago, a very smart man told me that I was not writing code for the compiler, I was writing code for the next poor slob that had to work on it.
Let's face it, most source code is going to be subject to rework or maintenance over its life span, so let's do what we can to make that next developer productive.
The key to this is reasonable commenting.One of the best ways I know of to teach developers to write maintainable code is to have them do support and maintenance for a while.
Developers learn quickly which styles work for maintenance, and which ones don't.As far as I am concerned, source code needs to look good as well as compile.
So I would go one step beyond TFA to say that style, indentation, proper symbol names, use of constants where appropriate, and (yes) proper commenting are all good indicators of quality in source code.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30119500</id>
	<title>had to put down my cheetos to reply to this!</title>
	<author>Anonymous</author>
	<datestamp>1258402080000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>// If it was hard to write, it should be hard to read.</p></htmltext>
<tokenext>// If it was hard to write , it should be hard to read .</tokentext>
<sentencetext>// If it was hard to write, it should be hard to read.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118484</id>
	<title>Try Wordpress</title>
	<author>danielpkern</author>
	<datestamp>1258399020000</datestamp>
	<modclass>Offtopic</modclass>
	<modscore>0</modscore>
	<htmltext>Why not just use wordpress &amp; download some of their comment plugins like the <a href="http://wordpress.org/extend/plugins/spell-checker/" title="wordpress.org" rel="nofollow">Spell Checker plugin</a> [wordpress.org]? We are looking to make the switch to this CMS for a number of sites (Cup of Comfort is one, which offers <a href="http://cupofcomfort.com/critiqueprogram/" title="cupofcomfort.com" rel="nofollow">story review</a> [cupofcomfort.com] services, a cool ongoing <a href="http://cupofcomfort.com/peopleschoice/" title="cupofcomfort.com" rel="nofollow">story contest</a> [cupofcomfort.com], and <a href="http://cupofcomfort.com/events/" title="cupofcomfort.com" rel="nofollow">writing webinars</a> [cupofcomfort.com]).</htmltext>
<tokenext>Why not just use wordpress &amp; download some of their comment plugins like the Spell Checker plugin [ wordpress.org ] ?
We are looking to make the switch to this CMS for a number of sites ( Cup of Comfort is one , which offers story review [ cupofcomfort.com ] services , a cool ongoing story contest [ cupofcomfort.com ] , and writing webinars [ cupofcomfort.com ] ) .</tokentext>
<sentencetext>Why not just use wordpress &amp; download some of their comment plugins like the Spell Checker plugin [wordpress.org]?
We are looking to make the switch to this CMS for a number of sites (Cup of Comfort is one, which offers story review [cupofcomfort.com] services, a cool ongoing story contest [cupofcomfort.com], and writing webinars [cupofcomfort.com]).</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117026</id>
	<title>Re:The comment may also be complex..</title>
	<author>Anonymous</author>
	<datestamp>1258394400000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><blockquote><div><p>if it passes the Unit Tests, then how is it really bad?</p></div></blockquote><p>If you believe that passing the unit tests means the code is acceptable and bug-free, you are fool and I don't want you touching any code I am responsible for.</p></div>
	</htmltext>
<tokenext>if it passes the Unit Tests , then how is it really bad ? If you believe that passing the unit tests means the code is acceptable and bug-free , you are fool and I do n't want you touching any code I am responsible for .</tokentext>
<sentencetext>if it passes the Unit Tests, then how is it really bad?If you believe that passing the unit tests means the code is acceptable and bug-free, you are fool and I don't want you touching any code I am responsible for.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116726</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30125534</id>
	<title>Re:I'm an expert!</title>
	<author>Verity\_Crux</author>
	<datestamp>1258390020000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>I have two comments, and they both go with a the same line of code:<br> <br>
Application.DoEvents();<nobr> <wbr></nobr>// the special sauce
<br><nobr> <wbr></nobr>//Application.DoEvents();<nobr> <wbr></nobr>// somebody's special sauce that needs to be done some other way</htmltext>
<tokenext>I have two comments , and they both go with a the same line of code : Application.DoEvents ( ) ; // the special sauce //Application.DoEvents ( ) ; // somebody 's special sauce that needs to be done some other way</tokentext>
<sentencetext>I have two comments, and they both go with a the same line of code: 
Application.DoEvents(); // the special sauce
 //Application.DoEvents(); // somebody's special sauce that needs to be done some other way</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116778</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30127352</id>
	<title>Utter, utter nonsense</title>
	<author>dugeen</author>
	<datestamp>1258457700000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>Natural language runs on human brains. Programming languages run on processors. The structure of the two different kinds of hardware differs so greatly that the only similarities are at the level of analogy. So you cannot draw useful conclusions about a person's use of a programming language from the way they use a natural language. In any case, someone who uses the term 'grammatical error' in the sense used in the blog post doesn't have a sufficiently sophisticated understanding of natural language to issue pronouncements on any related matter.</htmltext>
<tokenext>Natural language runs on human brains .
Programming languages run on processors .
The structure of the two different kinds of hardware differs so greatly that the only similarities are at the level of analogy .
So you can not draw useful conclusions about a person 's use of a programming language from the way they use a natural language .
In any case , someone who uses the term 'grammatical error ' in the sense used in the blog post does n't have a sufficiently sophisticated understanding of natural language to issue pronouncements on any related matter .</tokentext>
<sentencetext>Natural language runs on human brains.
Programming languages run on processors.
The structure of the two different kinds of hardware differs so greatly that the only similarities are at the level of analogy.
So you cannot draw useful conclusions about a person's use of a programming language from the way they use a natural language.
In any case, someone who uses the term 'grammatical error' in the sense used in the blog post doesn't have a sufficiently sophisticated understanding of natural language to issue pronouncements on any related matter.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30124120</id>
	<title>Re:The comment may also be complex..</title>
	<author>Capsaicin</author>
	<datestamp>1258377480000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p> <i>If you believe that passing the unit tests means the code is acceptable and bug-free, you are fool and I don't want you touching any code I am responsible for.</i> </p><p>If code passes unit testing it is acceptable <i>by defintion!</i>  The issue isn't whether the code is "bug-free," it's whether the unit tests are.</p></htmltext>
<tokenext>If you believe that passing the unit tests means the code is acceptable and bug-free , you are fool and I do n't want you touching any code I am responsible for .
If code passes unit testing it is acceptable by defintion !
The issue is n't whether the code is " bug-free , " it 's whether the unit tests are .</tokentext>
<sentencetext> If you believe that passing the unit tests means the code is acceptable and bug-free, you are fool and I don't want you touching any code I am responsible for.
If code passes unit testing it is acceptable by defintion!
The issue isn't whether the code is "bug-free," it's whether the unit tests are.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117026</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30127486</id>
	<title>The biggest problem with FOSS</title>
	<author>Shaiku</author>
	<datestamp>1258459980000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>I tend to document my algorithms in the code.  Even if the code is fairly straight forward, the comments explain what the code is *supposed* to do which simplifies the process of development and debugging.  I tend to briefly describe the purpose of functions and document their inputs and outputs.  It saves a lot of time when I revisit old code or share my code.  It takes a lot of effort to fully comment the code and I think programmers who don't do it are just lazy.

I've downloaded a ton of open source software in the hops of helping to debug or enhance it.  Virtually without fail, every project I have ever seen is completely without documentation or helpful comments.  It's as if somebody wrote a script to strip the comments out of every piece of code checked into the repository.  I find that extremely frustrating.  Even if the code is obvious and as simple as can be, there are still dozens of files to examine and commit to memory.  "Was that the print function in m\_system1.c or a\_systemb.c ?  Who the fuck named these files? "

A person's code is sort of like the county's 10 volume book of codes and regulations, or the legalese on the bottom of a contract, or my health insurance provider's explanation of my benefits.  Sure the words and sentences are clear enough to the person who wrote them, but the rest of us need judges, lawyers, and agents to give us the Cliff's Notes version.

Code needs comments.  I do believe that the effort that goes into commenting (or lack there of) is a reflection of the programmer's professionalism.  And in the case of FOSS, I think it would be a lot easier for the public to contribute and for the project to change hands if the original programmers could swallow their elitist pride or crawl out of their own heads for a second and actually write some comments at all.</htmltext>
<tokenext>I tend to document my algorithms in the code .
Even if the code is fairly straight forward , the comments explain what the code is * supposed * to do which simplifies the process of development and debugging .
I tend to briefly describe the purpose of functions and document their inputs and outputs .
It saves a lot of time when I revisit old code or share my code .
It takes a lot of effort to fully comment the code and I think programmers who do n't do it are just lazy .
I 've downloaded a ton of open source software in the hops of helping to debug or enhance it .
Virtually without fail , every project I have ever seen is completely without documentation or helpful comments .
It 's as if somebody wrote a script to strip the comments out of every piece of code checked into the repository .
I find that extremely frustrating .
Even if the code is obvious and as simple as can be , there are still dozens of files to examine and commit to memory .
" Was that the print function in m \ _system1.c or a \ _systemb.c ?
Who the fuck named these files ?
" A person 's code is sort of like the county 's 10 volume book of codes and regulations , or the legalese on the bottom of a contract , or my health insurance provider 's explanation of my benefits .
Sure the words and sentences are clear enough to the person who wrote them , but the rest of us need judges , lawyers , and agents to give us the Cliff 's Notes version .
Code needs comments .
I do believe that the effort that goes into commenting ( or lack there of ) is a reflection of the programmer 's professionalism .
And in the case of FOSS , I think it would be a lot easier for the public to contribute and for the project to change hands if the original programmers could swallow their elitist pride or crawl out of their own heads for a second and actually write some comments at all .</tokentext>
<sentencetext>I tend to document my algorithms in the code.
Even if the code is fairly straight forward, the comments explain what the code is *supposed* to do which simplifies the process of development and debugging.
I tend to briefly describe the purpose of functions and document their inputs and outputs.
It saves a lot of time when I revisit old code or share my code.
It takes a lot of effort to fully comment the code and I think programmers who don't do it are just lazy.
I've downloaded a ton of open source software in the hops of helping to debug or enhance it.
Virtually without fail, every project I have ever seen is completely without documentation or helpful comments.
It's as if somebody wrote a script to strip the comments out of every piece of code checked into the repository.
I find that extremely frustrating.
Even if the code is obvious and as simple as can be, there are still dozens of files to examine and commit to memory.
"Was that the print function in m\_system1.c or a\_systemb.c ?
Who the fuck named these files?
"

A person's code is sort of like the county's 10 volume book of codes and regulations, or the legalese on the bottom of a contract, or my health insurance provider's explanation of my benefits.
Sure the words and sentences are clear enough to the person who wrote them, but the rest of us need judges, lawyers, and agents to give us the Cliff's Notes version.
Code needs comments.
I do believe that the effort that goes into commenting (or lack there of) is a reflection of the programmer's professionalism.
And in the case of FOSS, I think it would be a lot easier for the public to contribute and for the project to change hands if the original programmers could swallow their elitist pride or crawl out of their own heads for a second and actually write some comments at all.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30119180</id>
	<title>Two skills involved: Mathematics vrs English</title>
	<author>GasparGMSwordsman</author>
	<datestamp>1258401120000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>Source code is a English (or human readable) language copy of a mathematical formulation. I have met a fair amount of very good programmers who had a very strong mathematical background but had very little strength when it came to writing.<br> <br>

Because of the mathematical background many comments were bad because they simply stated the equation (a + b = c as an example). Other times the author simply wrote a lackluster or bad English comment. In those example the CODE in question was superb.<br> <br>

My point, in summary, is that writing coherent and precise statements in any language is a skill. That skill is NOT needed to understand engineering or mathematics. Likewise, it is not needed to write good code.<br> <br> <br> <br>


Having said that point. Most people who write bad comments are usually not interested in the larger picture involved and seem to "cut corners" a bit to often. In my experience this leads to either bugs or a maintenance nightmare.<br> <br>

There is also something to be said about being a well rounded person.</htmltext>
<tokenext>Source code is a English ( or human readable ) language copy of a mathematical formulation .
I have met a fair amount of very good programmers who had a very strong mathematical background but had very little strength when it came to writing .
Because of the mathematical background many comments were bad because they simply stated the equation ( a + b = c as an example ) .
Other times the author simply wrote a lackluster or bad English comment .
In those example the CODE in question was superb .
My point , in summary , is that writing coherent and precise statements in any language is a skill .
That skill is NOT needed to understand engineering or mathematics .
Likewise , it is not needed to write good code .
Having said that point .
Most people who write bad comments are usually not interested in the larger picture involved and seem to " cut corners " a bit to often .
In my experience this leads to either bugs or a maintenance nightmare .
There is also something to be said about being a well rounded person .</tokentext>
<sentencetext>Source code is a English (or human readable) language copy of a mathematical formulation.
I have met a fair amount of very good programmers who had a very strong mathematical background but had very little strength when it came to writing.
Because of the mathematical background many comments were bad because they simply stated the equation (a + b = c as an example).
Other times the author simply wrote a lackluster or bad English comment.
In those example the CODE in question was superb.
My point, in summary, is that writing coherent and precise statements in any language is a skill.
That skill is NOT needed to understand engineering or mathematics.
Likewise, it is not needed to write good code.
Having said that point.
Most people who write bad comments are usually not interested in the larger picture involved and seem to "cut corners" a bit to often.
In my experience this leads to either bugs or a maintenance nightmare.
There is also something to be said about being a well rounded person.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30125378</id>
	<title>Re:Non-native English speakers</title>
	<author>ignavus</author>
	<datestamp>1258388160000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>English is not most people's first language. Be glad they want to write comments in English at all.</p></div><p>Some lines of Perl look like they were written by a baby at the keyboard.</p><p>34;#(*$(*\%)FKF))#$\_</p><p>Surprisingly, that is a valid Perl program.</p></div>
	</htmltext>
<tokenext>English is not most people 's first language .
Be glad they want to write comments in English at all.Some lines of Perl look like they were written by a baby at the keyboard.34 ; # ( * $ ( * \ % ) FKF ) ) # $ \ _Surprisingly , that is a valid Perl program .</tokentext>
<sentencetext>English is not most people's first language.
Be glad they want to write comments in English at all.Some lines of Perl look like they were written by a baby at the keyboard.34;#(*$(*\%)FKF))#$\_Surprisingly, that is a valid Perl program.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116734</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117276</id>
	<title>Bad Spelling in your comments</title>
	<author>smisle</author>
	<datestamp>1258395420000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I agree that a programmer must be anal about details, as one missing character can break your entire program.  But, how you write your code matters, how you spell, does not.</p><p>If you think of your programing language as just that, another language, it doesn't matter how poorly you understand your native tongue, as long as you can 'spell' with the language you are programing with.</p><p>Looking at the tone of the comments is 100\% different than looking at their grammar and spelling.  It's possible to have disturbing comments in prose... But all that just gives you an idea that there might be something wrong.</p></htmltext>
<tokenext>I agree that a programmer must be anal about details , as one missing character can break your entire program .
But , how you write your code matters , how you spell , does not.If you think of your programing language as just that , another language , it does n't matter how poorly you understand your native tongue , as long as you can 'spell ' with the language you are programing with.Looking at the tone of the comments is 100 \ % different than looking at their grammar and spelling .
It 's possible to have disturbing comments in prose... But all that just gives you an idea that there might be something wrong .</tokentext>
<sentencetext>I agree that a programmer must be anal about details, as one missing character can break your entire program.
But, how you write your code matters, how you spell, does not.If you think of your programing language as just that, another language, it doesn't matter how poorly you understand your native tongue, as long as you can 'spell' with the language you are programing with.Looking at the tone of the comments is 100\% different than looking at their grammar and spelling.
It's possible to have disturbing comments in prose... But all that just gives you an idea that there might be something wrong.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30123716</id>
	<title>Re:Existence of Comments</title>
	<author>Adm.Wiggin</author>
	<datestamp>1258375140000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>Why is this modded Funny?  Perl can be quite readable.  Too many bad programmers have given it a bad rep.<br>
My favorite example of code readability is: <tt>go\_outside() and play() unless its\_raining();</tt></htmltext>
<tokenext>Why is this modded Funny ?
Perl can be quite readable .
Too many bad programmers have given it a bad rep . My favorite example of code readability is : go \ _outside ( ) and play ( ) unless its \ _raining ( ) ;</tokentext>
<sentencetext>Why is this modded Funny?
Perl can be quite readable.
Too many bad programmers have given it a bad rep.
My favorite example of code readability is: go\_outside() and play() unless its\_raining();</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116872</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118240</id>
	<title>Re:10 PRIN "WTF"</title>
	<author>clone53421</author>
	<datestamp>1258398300000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>obvuous</p></div><p> <em>Must... refrain... from... commenting...</em> </p><p><div class="quote"><p>Loosing your mind</p></div><p>Elicited a "wut" reaction from me, until I read the rest of the sentence and realized you'd meant to say that.<nobr> <wbr></nobr>;)</p><p>I agree with you, anyway &ndash; I read the headline and though, "well, duh."</p></div>
	</htmltext>
<tokenext>obvuous Must... refrain... from... commenting... Loosing your mindElicited a " wut " reaction from me , until I read the rest of the sentence and realized you 'd meant to say that .
; ) I agree with you , anyway    I read the headline and though , " well , duh .
"</tokentext>
<sentencetext>obvuous Must... refrain... from... commenting... Loosing your mindElicited a "wut" reaction from me, until I read the rest of the sentence and realized you'd meant to say that.
;)I agree with you, anyway – I read the headline and though, "well, duh.
"
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116716</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118688</id>
	<title>Re:Seems reasonable</title>
	<author>CastrTroy</author>
	<datestamp>1258399680000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>Also, along the same lines.  If you are limited by time constraints, as most developers in the real world are, you would be much better off spending your time writing clear and concise code, and leaving out the comments entirely, than to spend time writing comments and code, simply because of some belief that comments must be there.  Quite often, comments fall out of date with the code that was written, as they aren't updated every time the code is updated, and at that point, only serve to confuse the user.</htmltext>
<tokenext>Also , along the same lines .
If you are limited by time constraints , as most developers in the real world are , you would be much better off spending your time writing clear and concise code , and leaving out the comments entirely , than to spend time writing comments and code , simply because of some belief that comments must be there .
Quite often , comments fall out of date with the code that was written , as they are n't updated every time the code is updated , and at that point , only serve to confuse the user .</tokentext>
<sentencetext>Also, along the same lines.
If you are limited by time constraints, as most developers in the real world are, you would be much better off spending your time writing clear and concise code, and leaving out the comments entirely, than to spend time writing comments and code, simply because of some belief that comments must be there.
Quite often, comments fall out of date with the code that was written, as they aren't updated every time the code is updated, and at that point, only serve to confuse the user.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116610</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117196</id>
	<title>T&#228;st&#228; voit hakea sanan kategorian (avain</title>
	<author>SombreReptile</author>
	<datestamp>1258395120000</datestamp>
	<modclass>Funny</modclass>
	<modscore>3</modscore>
	<htmltext><p>I cut text from Finnish language websites and paste it in as comments.  I don't know what it says, but it looks really cool.</p></htmltext>
<tokenext>I cut text from Finnish language websites and paste it in as comments .
I do n't know what it says , but it looks really cool .</tokentext>
<sentencetext>I cut text from Finnish language websites and paste it in as comments.
I don't know what it says, but it looks really cool.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30166536</id>
	<title>Re:The comment may also be complex..</title>
	<author>awright69</author>
	<datestamp>1258637220000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>I second that. I am responsible for supporting a steaming pile of code from a major electronics company well-known for their reasonably good hardware. I can't tell you how many times I was told, "But all the modules passed their unit tests!" - to which I reply, "All fine and dandy, but did any of your tests check the INTEROPERABILITY of the modules, or the application's behaviour when linked and assembled?" I've caught them in this little oopsie too many times; I'd have had the SQA manager fired long ago were I a direct employee of said organisation.</htmltext>
<tokenext>I second that .
I am responsible for supporting a steaming pile of code from a major electronics company well-known for their reasonably good hardware .
I ca n't tell you how many times I was told , " But all the modules passed their unit tests !
" - to which I reply , " All fine and dandy , but did any of your tests check the INTEROPERABILITY of the modules , or the application 's behaviour when linked and assembled ?
" I 've caught them in this little oopsie too many times ; I 'd have had the SQA manager fired long ago were I a direct employee of said organisation .</tokentext>
<sentencetext>I second that.
I am responsible for supporting a steaming pile of code from a major electronics company well-known for their reasonably good hardware.
I can't tell you how many times I was told, "But all the modules passed their unit tests!
" - to which I reply, "All fine and dandy, but did any of your tests check the INTEROPERABILITY of the modules, or the application's behaviour when linked and assembled?
" I've caught them in this little oopsie too many times; I'd have had the SQA manager fired long ago were I a direct employee of said organisation.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117026</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117464</id>
	<title>Comments...</title>
	<author>CFBMoo1</author>
	<datestamp>1258396080000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>I write my comments in my code for the person coming in and having no clue about anything but has to fix something. It can happen and I've had to deal with situations like that for code that had no comments or documentation. Comments are there not only to remind me months or years down the road what I did back then but also to help the poor soul who gets thrown in to the project because maybe something happened to me and I want as much info as possible not only in the documentation but also the code. For all I know something may have happened to the documentation as well.</htmltext>
<tokenext>I write my comments in my code for the person coming in and having no clue about anything but has to fix something .
It can happen and I 've had to deal with situations like that for code that had no comments or documentation .
Comments are there not only to remind me months or years down the road what I did back then but also to help the poor soul who gets thrown in to the project because maybe something happened to me and I want as much info as possible not only in the documentation but also the code .
For all I know something may have happened to the documentation as well .</tokentext>
<sentencetext>I write my comments in my code for the person coming in and having no clue about anything but has to fix something.
It can happen and I've had to deal with situations like that for code that had no comments or documentation.
Comments are there not only to remind me months or years down the road what I did back then but also to help the poor soul who gets thrown in to the project because maybe something happened to me and I want as much info as possible not only in the documentation but also the code.
For all I know something may have happened to the documentation as well.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117008</id>
	<title>What about foreign coders? What about dyslexics?</title>
	<author>Viol8</author>
	<datestamp>1258394340000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>There are many coders who work in a country where the language is not their first language. Does this mean the code they write is rubbish if they make some spelling mistakes in the comments? And I've met at least 2 genius level coders who had serious dyslexia and you could hardly make head nor tail of their comments, but the code they wrote was superb.</p><p>This whole premise is just a joke. Next they'll be saying people who can't program very well wouldn't be good at writing any form of document.</p></htmltext>
<tokenext>There are many coders who work in a country where the language is not their first language .
Does this mean the code they write is rubbish if they make some spelling mistakes in the comments ?
And I 've met at least 2 genius level coders who had serious dyslexia and you could hardly make head nor tail of their comments , but the code they wrote was superb.This whole premise is just a joke .
Next they 'll be saying people who ca n't program very well would n't be good at writing any form of document .</tokentext>
<sentencetext>There are many coders who work in a country where the language is not their first language.
Does this mean the code they write is rubbish if they make some spelling mistakes in the comments?
And I've met at least 2 genius level coders who had serious dyslexia and you could hardly make head nor tail of their comments, but the code they wrote was superb.This whole premise is just a joke.
Next they'll be saying people who can't program very well wouldn't be good at writing any form of document.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30165302</id>
	<title>Non onoonoeoro</title>
	<author>DanielSmedegaardBuus</author>
	<datestamp>1258631640000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Well, they're recognizing the symptoms, but missing the point completely.</p><p>It's the typical IT professional's misconception: "I'm using computers, therefore my skills are based on mathematics."</p><p>No, no, no, no, no. A programmer is a linguistic being. Mathematical skills are most definitely a plus, but in my experience, the most gifted developers are the ones who are also able to express themselves verbally and in writing, and who understand the difference between the thing and "the thing".</p><p>Mastering a programming LANGUAGE is different to mastering a human language only in that when programming, you're actually CREATING a language. The levels of abstraction are immense when you know what you're doing, as is the power, and really - if non-geeks like Heidegger, Foucault, Berger and Luckmann had the tools back then that we have know, they'd been friggin' ecstatic!</p><p>You want a good developer? Look at how the resum&#233; and application are written and constructed. You can sort out the first 90\% of crud right there. Find someone who knows how to express himself or herself concisively and correctly and you have a starting point.</p><p>(Btw, I'm Danish, so I know my English is crap<nobr> <wbr></nobr>;) )</p></htmltext>
<tokenext>Well , they 're recognizing the symptoms , but missing the point completely.It 's the typical IT professional 's misconception : " I 'm using computers , therefore my skills are based on mathematics .
" No , no , no , no , no .
A programmer is a linguistic being .
Mathematical skills are most definitely a plus , but in my experience , the most gifted developers are the ones who are also able to express themselves verbally and in writing , and who understand the difference between the thing and " the thing " .Mastering a programming LANGUAGE is different to mastering a human language only in that when programming , you 're actually CREATING a language .
The levels of abstraction are immense when you know what you 're doing , as is the power , and really - if non-geeks like Heidegger , Foucault , Berger and Luckmann had the tools back then that we have know , they 'd been friggin ' ecstatic ! You want a good developer ?
Look at how the resum   and application are written and constructed .
You can sort out the first 90 \ % of crud right there .
Find someone who knows how to express himself or herself concisively and correctly and you have a starting point .
( Btw , I 'm Danish , so I know my English is crap ; ) )</tokentext>
<sentencetext>Well, they're recognizing the symptoms, but missing the point completely.It's the typical IT professional's misconception: "I'm using computers, therefore my skills are based on mathematics.
"No, no, no, no, no.
A programmer is a linguistic being.
Mathematical skills are most definitely a plus, but in my experience, the most gifted developers are the ones who are also able to express themselves verbally and in writing, and who understand the difference between the thing and "the thing".Mastering a programming LANGUAGE is different to mastering a human language only in that when programming, you're actually CREATING a language.
The levels of abstraction are immense when you know what you're doing, as is the power, and really - if non-geeks like Heidegger, Foucault, Berger and Luckmann had the tools back then that we have know, they'd been friggin' ecstatic!You want a good developer?
Look at how the resumé and application are written and constructed.
You can sort out the first 90\% of crud right there.
Find someone who knows how to express himself or herself concisively and correctly and you have a starting point.
(Btw, I'm Danish, so I know my English is crap ;) )</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118850</id>
	<title>Re:The comment may also be complex..</title>
	<author>ardle</author>
	<datestamp>1258400160000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>2</modscore>
	<htmltext>If the poster could have got the code working <i>in all cases</i>, rather than (apparently) some special case, do you not think he would have written the best possible code and not added a comment to say otherwise?
<br>I think you are following a "false" (i.e. unlikely enough to be a bit absurd) argument here.
<br>And hats off to the coder with humanity enough to make other coders' jobs easier if things should get to the point of having to fix said code: at least we know where to look first.<p><div class="quote"><p>First they came for the project managers...</p></div></div>
	</htmltext>
<tokenext>If the poster could have got the code working in all cases , rather than ( apparently ) some special case , do you not think he would have written the best possible code and not added a comment to say otherwise ?
I think you are following a " false " ( i.e .
unlikely enough to be a bit absurd ) argument here .
And hats off to the coder with humanity enough to make other coders ' jobs easier if things should get to the point of having to fix said code : at least we know where to look first.First they came for the project managers.. .</tokentext>
<sentencetext>If the poster could have got the code working in all cases, rather than (apparently) some special case, do you not think he would have written the best possible code and not added a comment to say otherwise?
I think you are following a "false" (i.e.
unlikely enough to be a bit absurd) argument here.
And hats off to the coder with humanity enough to make other coders' jobs easier if things should get to the point of having to fix said code: at least we know where to look first.First they came for the project managers...
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116724</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30123100</id>
	<title>Pheew</title>
	<author>CptPicard</author>
	<datestamp>1258372140000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Glad I don't comment.</p></htmltext>
<tokenext>Glad I do n't comment .</tokentext>
<sentencetext>Glad I don't comment.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117566</id>
	<title>Re:You are not expected to understand this</title>
	<author>gstoddart</author>
	<datestamp>1258396260000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>2</modscore>
	<htmltext><blockquote><div><p>So here's an example of a comment that does an excellent (I assume) job of explaining why the code is doing what it's doing, yet the whole thing is so complicated that Ritchie even needed to acknowledge that the comment probably wasn't going to be of much help either with an amusing, and now somewhat famous, statement.</p></div></blockquote><p>In fairness to Ritchie, he was programming on bare metal and breaking new ground.  OS level code talking directly to hardware can get pretty grotty because of all of the vagaries that can be going on that aren't readily apparent without the device manual and some experience.</p><p>At least he did comment it, and there was enough information in there to at least give context for what he was doing.</p><p>Cheers</p></div>
	</htmltext>
<tokenext>So here 's an example of a comment that does an excellent ( I assume ) job of explaining why the code is doing what it 's doing , yet the whole thing is so complicated that Ritchie even needed to acknowledge that the comment probably was n't going to be of much help either with an amusing , and now somewhat famous , statement.In fairness to Ritchie , he was programming on bare metal and breaking new ground .
OS level code talking directly to hardware can get pretty grotty because of all of the vagaries that can be going on that are n't readily apparent without the device manual and some experience.At least he did comment it , and there was enough information in there to at least give context for what he was doing.Cheers</tokentext>
<sentencetext>So here's an example of a comment that does an excellent (I assume) job of explaining why the code is doing what it's doing, yet the whole thing is so complicated that Ritchie even needed to acknowledge that the comment probably wasn't going to be of much help either with an amusing, and now somewhat famous, statement.In fairness to Ritchie, he was programming on bare metal and breaking new ground.
OS level code talking directly to hardware can get pretty grotty because of all of the vagaries that can be going on that aren't readily apparent without the device manual and some experience.At least he did comment it, and there was enough information in there to at least give context for what he was doing.Cheers
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117090</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118626</id>
	<title>Who needs comments?</title>
	<author>thetoadwarrior</author>
	<datestamp>1258399440000</datestamp>
	<modclass>Troll</modclass>
	<modscore>0</modscore>
	<htmltext>All my variables are single digits too. I try to keep method names no longer than 4 digits and I get a wood over cryptic package names. When you write perfect code you don't need comments or dumbed down names. It's just so obvious what is happening in the code.</htmltext>
<tokenext>All my variables are single digits too .
I try to keep method names no longer than 4 digits and I get a wood over cryptic package names .
When you write perfect code you do n't need comments or dumbed down names .
It 's just so obvious what is happening in the code .</tokentext>
<sentencetext>All my variables are single digits too.
I try to keep method names no longer than 4 digits and I get a wood over cryptic package names.
When you write perfect code you don't need comments or dumbed down names.
It's just so obvious what is happening in the code.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30123562</id>
	<title>WTF comments</title>
	<author>Anonymous</author>
	<datestamp>1258374360000</datestamp>
	<modclass>Funny</modclass>
	<modscore>1</modscore>
	<htmltext><p>You should at least comment your code, such that the next time (3 am) someone (you) is looking at your code you can make some sense of it.</p></htmltext>
<tokenext>You should at least comment your code , such that the next time ( 3 am ) someone ( you ) is looking at your code you can make some sense of it .</tokentext>
<sentencetext>You should at least comment your code, such that the next time (3 am) someone (you) is looking at your code you can make some sense of it.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116628</id>
	<title>Excuses...</title>
	<author>Anonymous</author>
	<datestamp>1258393080000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>The only times I find myself making excuses is when management didn't properly give the requirements or change the requirements to late in the game...so you have to make bad programming decisions as a band-aid until a complete rewrite can be done proper...just to meet a deadline that was shortened or a deadline that was insanely impossible because someone oversold your departments abilities...or a deadline that doesn't adjust to the new fangle features that were always supposed to be in there. Not everything is the prgrammer's fault in this world...in fact I think you'll find that very little of it is to be laid to rest at the programmer's feet. Expectations are high, pay is low, and management simply assumes cause there are teenage kids telling them they can write the same thing in shorter time means they know what they are talking about when they don't have the slightest clue...haven't coded anything over 500 lines of code.</p></htmltext>
<tokenext>The only times I find myself making excuses is when management did n't properly give the requirements or change the requirements to late in the game...so you have to make bad programming decisions as a band-aid until a complete rewrite can be done proper...just to meet a deadline that was shortened or a deadline that was insanely impossible because someone oversold your departments abilities...or a deadline that does n't adjust to the new fangle features that were always supposed to be in there .
Not everything is the prgrammer 's fault in this world...in fact I think you 'll find that very little of it is to be laid to rest at the programmer 's feet .
Expectations are high , pay is low , and management simply assumes cause there are teenage kids telling them they can write the same thing in shorter time means they know what they are talking about when they do n't have the slightest clue...have n't coded anything over 500 lines of code .</tokentext>
<sentencetext>The only times I find myself making excuses is when management didn't properly give the requirements or change the requirements to late in the game...so you have to make bad programming decisions as a band-aid until a complete rewrite can be done proper...just to meet a deadline that was shortened or a deadline that was insanely impossible because someone oversold your departments abilities...or a deadline that doesn't adjust to the new fangle features that were always supposed to be in there.
Not everything is the prgrammer's fault in this world...in fact I think you'll find that very little of it is to be laid to rest at the programmer's feet.
Expectations are high, pay is low, and management simply assumes cause there are teenage kids telling them they can write the same thing in shorter time means they know what they are talking about when they don't have the slightest clue...haven't coded anything over 500 lines of code.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118080</id>
	<title>I can't code worth anything</title>
	<author>Anonymous</author>
	<datestamp>1258397820000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>...but my comments are <i>awesome</i>.</p><p>Seriously, just look at all the +5 A.C. comments I post.</p></htmltext>
<tokenext>...but my comments are awesome.Seriously , just look at all the + 5 A.C. comments I post .</tokentext>
<sentencetext>...but my comments are awesome.Seriously, just look at all the +5 A.C. comments I post.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116776</id>
	<title>Doesn't work</title>
	<author>Yvan256</author>
	<datestamp>1258393500000</datestamp>
	<modclass>Funny</modclass>
	<modscore>2</modscore>
	<htmltext><p>I always try to comment my code, but then the compiler keeps telling me there's no code to compile.</p></htmltext>
<tokenext>I always try to comment my code , but then the compiler keeps telling me there 's no code to compile .</tokentext>
<sentencetext>I always try to comment my code, but then the compiler keeps telling me there's no code to compile.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116852</id>
	<title>Yes, that's bad coding</title>
	<author>Anonymous</author>
	<datestamp>1258393740000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>5</modscore>
	<htmltext><p><div class="quote"><p>I once coded a function that varied depending on what quadrant (+x,+y; -x, +y; -x,-y; +x,-y) it was in. I couldn't get it to work right in the second quadrant, but finally got it working by chance and said so in my comments. The code worked, but I didn't understand why and said so. Is that bad coding? It worked!</p></div><p>If you don't understand why it worked, then you don't know how it worked.  Consequently, you have no idea under what circumstances it won't work.  Unless your unit tests enumerated every possible set of inputs, you don't actually know it worked.  Just because code works for some inputs doesn't mean it works.</p></div>
	</htmltext>
<tokenext>I once coded a function that varied depending on what quadrant ( + x , + y ; -x , + y ; -x,-y ; + x,-y ) it was in .
I could n't get it to work right in the second quadrant , but finally got it working by chance and said so in my comments .
The code worked , but I did n't understand why and said so .
Is that bad coding ?
It worked ! If you do n't understand why it worked , then you do n't know how it worked .
Consequently , you have no idea under what circumstances it wo n't work .
Unless your unit tests enumerated every possible set of inputs , you do n't actually know it worked .
Just because code works for some inputs does n't mean it works .</tokentext>
<sentencetext>I once coded a function that varied depending on what quadrant (+x,+y; -x, +y; -x,-y; +x,-y) it was in.
I couldn't get it to work right in the second quadrant, but finally got it working by chance and said so in my comments.
The code worked, but I didn't understand why and said so.
Is that bad coding?
It worked!If you don't understand why it worked, then you don't know how it worked.
Consequently, you have no idea under what circumstances it won't work.
Unless your unit tests enumerated every possible set of inputs, you don't actually know it worked.
Just because code works for some inputs doesn't mean it works.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116652</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30122260</id>
	<title>I comment, therefore I code?</title>
	<author>Sterculius</author>
	<datestamp>1258368660000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>I don't comment my code at all<nobr> <wbr></nobr>... does that mean it doesn't really exist?</htmltext>
<tokenext>I do n't comment my code at all ... does that mean it does n't really exist ?</tokentext>
<sentencetext>I don't comment my code at all ... does that mean it doesn't really exist?</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30123596</id>
	<title>Real men</title>
	<author>halcyon1234</author>
	<datestamp>1258374480000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>Real men don't comment their code. They put it on ftp and let others create a wiki for it.</htmltext>
<tokenext>Real men do n't comment their code .
They put it on ftp and let others create a wiki for it .</tokentext>
<sentencetext>Real men don't comment their code.
They put it on ftp and let others create a wiki for it.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121666</id>
	<title>Re:Existence of Comments</title>
	<author>Sandbags</author>
	<datestamp>1258366920000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Yea, and then what do I do with LISP?!?!?!?  lol.</p><p>Self commenting code is what CoBOL was designed to do.  Have you ever coded in CoBOL?  it sucks...  Too restrictive, and too long winded.  I want my code clean, compressed, and simple.  the comments can spell it out in a readable language...</p><p>Also, apparently you have also never written in Assembler, RPG, or any of the other obscure languages of old.</p><p>Further, just because i know the code calls libraries and variables and strings/lists, does NOT mean i want to go digging through other sections of code to know what that is or why.  If I'm calling something, i state what it is there next to it for reference unless its so glaringly obvious it doesn't need it.</p><p>I'm not saying every line needs a comment (it doesn't hurt), but there should be zero ambiguity in what a code segment does, what the inputs, outputs, validation, debug lines, etc are.</p></htmltext>
<tokenext>Yea , and then what do I do with LISP ? ! ? ! ? ! ?
lol.Self commenting code is what CoBOL was designed to do .
Have you ever coded in CoBOL ?
it sucks... Too restrictive , and too long winded .
I want my code clean , compressed , and simple .
the comments can spell it out in a readable language...Also , apparently you have also never written in Assembler , RPG , or any of the other obscure languages of old.Further , just because i know the code calls libraries and variables and strings/lists , does NOT mean i want to go digging through other sections of code to know what that is or why .
If I 'm calling something , i state what it is there next to it for reference unless its so glaringly obvious it does n't need it.I 'm not saying every line needs a comment ( it does n't hurt ) , but there should be zero ambiguity in what a code segment does , what the inputs , outputs , validation , debug lines , etc are .</tokentext>
<sentencetext>Yea, and then what do I do with LISP?!?!?!?
lol.Self commenting code is what CoBOL was designed to do.
Have you ever coded in CoBOL?
it sucks...  Too restrictive, and too long winded.
I want my code clean, compressed, and simple.
the comments can spell it out in a readable language...Also, apparently you have also never written in Assembler, RPG, or any of the other obscure languages of old.Further, just because i know the code calls libraries and variables and strings/lists, does NOT mean i want to go digging through other sections of code to know what that is or why.
If I'm calling something, i state what it is there next to it for reference unless its so glaringly obvious it doesn't need it.I'm not saying every line needs a comment (it doesn't hurt), but there should be zero ambiguity in what a code segment does, what the inputs, outputs, validation, debug lines, etc are.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116872</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121396</id>
	<title>Re:Rubish</title>
	<author>clone53421</author>
	<datestamp>1258365720000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>"Rubish" made me chuckle.</p></htmltext>
<tokenext>" Rubish " made me chuckle .</tokentext>
<sentencetext>"Rubish" made me chuckle.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118256</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30125760</id>
	<title>Re:Existence of Comments</title>
	<author>Anonymous</author>
	<datestamp>1258392660000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>In Soviet Russia, the code comments on YOU!</p></htmltext>
<tokenext>In Soviet Russia , the code comments on YOU !</tokentext>
<sentencetext>In Soviet Russia, the code comments on YOU!</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116872</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117422</id>
	<title>Bill Watterson put it so eloquently</title>
	<author>Anonymous</author>
	<datestamp>1258395960000</datestamp>
	<modclass>Funny</modclass>
	<modscore>2</modscore>
	<htmltext><p><a href="http://74.125.93.132/search?q=cache:6l-STbmY0DkJ:www.gocomics.com/calvinandhobbes/1993/07/28/+site:www.gocomics.com/calvinandhobbes/1993/07/28/&amp;cd=1&amp;hl=en&amp;ct=clnk&amp;gl=us" title="74.125.93.132" rel="nofollow">http://74.125.93.132/search?q=cache:6l-STbmY0DkJ:www.gocomics.com/calvinandhobbes/1993/07/28/+site:www.gocomics.com/calvinandhobbes/1993/07/28/&amp;cd=1&amp;hl=en&amp;ct=clnk&amp;gl=us</a> [74.125.93.132] (sorry, Google cached copy because the website is weird)</p><p>CALVIN: "Dad, what's a control freak?"<br>DAD: "That's what lazy, slipshod, careless, cut-corner workers call anyone who cares enough to do something right."<br>CALVIN: "Am I in the presence of their king? Should I kneel?"<br>DAD: "If anything works in this world, it's because one of us took charge."</p></htmltext>
<tokenext>http : //74.125.93.132/search ? q = cache : 6l-STbmY0DkJ : www.gocomics.com/calvinandhobbes/1993/07/28/ + site : www.gocomics.com/calvinandhobbes/1993/07/28/&amp;cd = 1&amp;hl = en&amp;ct = clnk&amp;gl = us [ 74.125.93.132 ] ( sorry , Google cached copy because the website is weird ) CALVIN : " Dad , what 's a control freak ?
" DAD : " That 's what lazy , slipshod , careless , cut-corner workers call anyone who cares enough to do something right .
" CALVIN : " Am I in the presence of their king ?
Should I kneel ?
" DAD : " If anything works in this world , it 's because one of us took charge .
"</tokentext>
<sentencetext>http://74.125.93.132/search?q=cache:6l-STbmY0DkJ:www.gocomics.com/calvinandhobbes/1993/07/28/+site:www.gocomics.com/calvinandhobbes/1993/07/28/&amp;cd=1&amp;hl=en&amp;ct=clnk&amp;gl=us [74.125.93.132] (sorry, Google cached copy because the website is weird)CALVIN: "Dad, what's a control freak?
"DAD: "That's what lazy, slipshod, careless, cut-corner workers call anyone who cares enough to do something right.
"CALVIN: "Am I in the presence of their king?
Should I kneel?
"DAD: "If anything works in this world, it's because one of us took charge.
"</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116868</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116978</id>
	<title>Forget the comments, look at the documentation</title>
	<author>Anonymous</author>
	<datestamp>1258394220000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>If the documentation is incomprehensible or missing, then the software generally wasn't well thought out or planned ahead of time, but rather just grew as an accretion of hacks.</p><p>This is particularly true of API documentation. I've even encountered crackpots in the Rails community who think that you don't need API documentation if you have unit tests; their code was abysmally unreliable, unstable, and performed poorly.</p></htmltext>
<tokenext>If the documentation is incomprehensible or missing , then the software generally was n't well thought out or planned ahead of time , but rather just grew as an accretion of hacks.This is particularly true of API documentation .
I 've even encountered crackpots in the Rails community who think that you do n't need API documentation if you have unit tests ; their code was abysmally unreliable , unstable , and performed poorly .</tokentext>
<sentencetext>If the documentation is incomprehensible or missing, then the software generally wasn't well thought out or planned ahead of time, but rather just grew as an accretion of hacks.This is particularly true of API documentation.
I've even encountered crackpots in the Rails community who think that you don't need API documentation if you have unit tests; their code was abysmally unreliable, unstable, and performed poorly.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116886</id>
	<title>Bullshit!</title>
	<author>bongey</author>
	<datestamp>1258393860000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>Talk is cheap. Show me the code.Linus Torvalds</p> </div><p>

I am going with Linus on this one, not some tech author nazi.
<br>
I have found too often the comments says the code does X, and it does Y. What is even better is when the code is wrong. Just love it when that happens.
I have had to go as far to prove to someone in the comments that there code was wrong to accept that there code was wrong, and he are grammar nazi too, so I say bullshit on this.
<br>
Programming is a art in itself, good coders can "read" the code. Comments are nice, but they are not end all, nor a guarantee the code is correct or good.Often it can be the opposite.</p></div>
	</htmltext>
<tokenext>Talk is cheap .
Show me the code.Linus Torvalds I am going with Linus on this one , not some tech author nazi .
I have found too often the comments says the code does X , and it does Y. What is even better is when the code is wrong .
Just love it when that happens .
I have had to go as far to prove to someone in the comments that there code was wrong to accept that there code was wrong , and he are grammar nazi too , so I say bullshit on this .
Programming is a art in itself , good coders can " read " the code .
Comments are nice , but they are not end all , nor a guarantee the code is correct or good.Often it can be the opposite .</tokentext>
<sentencetext>Talk is cheap.
Show me the code.Linus Torvalds 

I am going with Linus on this one, not some tech author nazi.
I have found too often the comments says the code does X, and it does Y. What is even better is when the code is wrong.
Just love it when that happens.
I have had to go as far to prove to someone in the comments that there code was wrong to accept that there code was wrong, and he are grammar nazi too, so I say bullshit on this.
Programming is a art in itself, good coders can "read" the code.
Comments are nice, but they are not end all, nor a guarantee the code is correct or good.Often it can be the opposite.
	</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117944</id>
	<title>Re:Well, duh.</title>
	<author>ericspinder</author>
	<datestamp>1258397400000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>. But that's because the professor (or rather, the TA:s) need to quickly read through 50 or so computer lab reports every couple of weeks, and doing so without comments takes ages</p></div><p>However in the business world we have all the time in the world?</p></div>
	</htmltext>
<tokenext>.
But that 's because the professor ( or rather , the TA : s ) need to quickly read through 50 or so computer lab reports every couple of weeks , and doing so without comments takes agesHowever in the business world we have all the time in the world ?</tokentext>
<sentencetext>.
But that's because the professor (or rather, the TA:s) need to quickly read through 50 or so computer lab reports every couple of weeks, and doing so without comments takes agesHowever in the business world we have all the time in the world?
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116970</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120832</id>
	<title>Re:Seems reasonable</title>
	<author>Anonymous</author>
	<datestamp>1258363440000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Fortunately, you don't have to spend any time or effort on your grammar when posting to Slashdot.</p></htmltext>
<tokenext>Fortunately , you do n't have to spend any time or effort on your grammar when posting to Slashdot .</tokentext>
<sentencetext>Fortunately, you don't have to spend any time or effort on your grammar when posting to Slashdot.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116610</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118448</id>
	<title>20 GOTO 10</title>
	<author>Anonymous</author>
	<datestamp>1258398840000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Nothing sloppy about GOTO, it makes my code work<nobr> <wbr></nobr>:)</p></htmltext>
<tokenext>Nothing sloppy about GOTO , it makes my code work : )</tokentext>
<sentencetext>Nothing sloppy about GOTO, it makes my code work :)</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116716</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121028</id>
	<title>Re:The comment may also be complex..</title>
	<author>Anonymous</author>
	<datestamp>1258364280000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>No.</p><p>The metric for "good" code is<nobr> <wbr></nobr>.. Euros.</p></htmltext>
<tokenext>No.The metric for " good " code is .. Euros .</tokentext>
<sentencetext>No.The metric for "good" code is .. Euros.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117028</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117968</id>
	<title>Tell the tramp to shut up.</title>
	<author>tjstork</author>
	<datestamp>1258397460000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I have no idea who this self proclaimed expert is, and as far as I'm concerned, her sweeping statements suggest that nobody else should either.</p><p>Go away!</p></htmltext>
<tokenext>I have no idea who this self proclaimed expert is , and as far as I 'm concerned , her sweeping statements suggest that nobody else should either.Go away !</tokentext>
<sentencetext>I have no idea who this self proclaimed expert is, and as far as I'm concerned, her sweeping statements suggest that nobody else should either.Go away!</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116724</id>
	<title>Re:The comment may also be complex..</title>
	<author>Anonymous</author>
	<datestamp>1258393380000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>5</modscore>
	<htmltext><p> <i>It worked!</i>
</p><p>
Are you sure about that?  Did you really have enough of an understanding of the conditions
to make that statement?
</p><p>
Chances are, it worked in the subset of cases you understood, and maybe in the subset of cases that the app needed at the time.  In the future, though, all bets are off<nobr> <wbr></nobr>...
</p></htmltext>
<tokenext>It worked !
Are you sure about that ?
Did you really have enough of an understanding of the conditions to make that statement ?
Chances are , it worked in the subset of cases you understood , and maybe in the subset of cases that the app needed at the time .
In the future , though , all bets are off .. .</tokentext>
<sentencetext> It worked!
Are you sure about that?
Did you really have enough of an understanding of the conditions
to make that statement?
Chances are, it worked in the subset of cases you understood, and maybe in the subset of cases that the app needed at the time.
In the future, though, all bets are off ...
</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116652</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118176</id>
	<title>Re:Bullshit!</title>
	<author>natehoy</author>
	<datestamp>1258398060000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>The important thing that a comment gives you is not the how.  You can get the how by reading the code.</p><p>What an appropriate comment will give you is the WHY.</p><p>Unimportant for a lot of web development, I suppose, when you are pretty much dealing with the data on a form and bouncing bits of it against a database.  But for transactional processing, the why can be easily non-obvious in the code, and important to know.</p></htmltext>
<tokenext>The important thing that a comment gives you is not the how .
You can get the how by reading the code.What an appropriate comment will give you is the WHY.Unimportant for a lot of web development , I suppose , when you are pretty much dealing with the data on a form and bouncing bits of it against a database .
But for transactional processing , the why can be easily non-obvious in the code , and important to know .</tokentext>
<sentencetext>The important thing that a comment gives you is not the how.
You can get the how by reading the code.What an appropriate comment will give you is the WHY.Unimportant for a lot of web development, I suppose, when you are pretty much dealing with the data on a form and bouncing bits of it against a database.
But for transactional processing, the why can be easily non-obvious in the code, and important to know.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116886</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30131254</id>
	<title>Re:You are not expected to understand this</title>
	<author>mallowman</author>
	<datestamp>1258483800000</datestamp>
	<modclass>Informativ</modclass>
	<modscore>2</modscore>
	<htmltext><p>The first C compilers/linkers would only look at the first 8 characters of identifiers to determine equality. That kind of limits the sort of names you could use in a OS sized code-base and still maintain uniqueness. I'd say it was better to keep all identifiers under 8 characters than to risk the possibility of unintended ambiguous names.</p></htmltext>
<tokenext>The first C compilers/linkers would only look at the first 8 characters of identifiers to determine equality .
That kind of limits the sort of names you could use in a OS sized code-base and still maintain uniqueness .
I 'd say it was better to keep all identifiers under 8 characters than to risk the possibility of unintended ambiguous names .</tokentext>
<sentencetext>The first C compilers/linkers would only look at the first 8 characters of identifiers to determine equality.
That kind of limits the sort of names you could use in a OS sized code-base and still maintain uniqueness.
I'd say it was better to keep all identifiers under 8 characters than to risk the possibility of unintended ambiguous names.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121092</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30119376</id>
	<title>Re:Job Security</title>
	<author>murdocj</author>
	<datestamp>1258401660000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Well, I'll take no indenting over random indenting.  I once had to work through some Perl code that was so ugly that I felt dirty just being in the same directory with the code.  Lots of copies of the same code, commenting used as source control, random indenting... at some point I felt like no one could have written such stuff by accident, it had to be malign intent.  I think I decided that when I realized that the code was deliberately taking the log output and rewriting the log out of order, which explained why the impossible sequence of events I was seeing in the log.</p></htmltext>
<tokenext>Well , I 'll take no indenting over random indenting .
I once had to work through some Perl code that was so ugly that I felt dirty just being in the same directory with the code .
Lots of copies of the same code , commenting used as source control , random indenting... at some point I felt like no one could have written such stuff by accident , it had to be malign intent .
I think I decided that when I realized that the code was deliberately taking the log output and rewriting the log out of order , which explained why the impossible sequence of events I was seeing in the log .</tokentext>
<sentencetext>Well, I'll take no indenting over random indenting.
I once had to work through some Perl code that was so ugly that I felt dirty just being in the same directory with the code.
Lots of copies of the same code, commenting used as source control, random indenting... at some point I felt like no one could have written such stuff by accident, it had to be malign intent.
I think I decided that when I realized that the code was deliberately taking the log output and rewriting the log out of order, which explained why the impossible sequence of events I was seeing in the log.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117098</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116748</id>
	<title>Arguments for and against</title>
	<author>NtwoO</author>
	<datestamp>1258393440000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>One of the best programmers on our team can not spell to save his life. He also does not touch type (a proficiency I always considered a basic requirement when interfacing with computers for your profession). He thus proves that it is not a hard and fast rule.
<p>That being said, we work in a company where virtually all code is reviewed. Long winded comments introduce maintainability issues, since the comment can diverge from the working in time. Extensive spelling mistakes in them certainly becomes irritating, especially since there are plenty of good editors available with spell checking included. That just points to sloppiness. Not bothering to use a tool's features shows no pursuit of excellence and that certainly places doubts on the rest.</p></htmltext>
<tokenext>One of the best programmers on our team can not spell to save his life .
He also does not touch type ( a proficiency I always considered a basic requirement when interfacing with computers for your profession ) .
He thus proves that it is not a hard and fast rule .
That being said , we work in a company where virtually all code is reviewed .
Long winded comments introduce maintainability issues , since the comment can diverge from the working in time .
Extensive spelling mistakes in them certainly becomes irritating , especially since there are plenty of good editors available with spell checking included .
That just points to sloppiness .
Not bothering to use a tool 's features shows no pursuit of excellence and that certainly places doubts on the rest .</tokentext>
<sentencetext>One of the best programmers on our team can not spell to save his life.
He also does not touch type (a proficiency I always considered a basic requirement when interfacing with computers for your profession).
He thus proves that it is not a hard and fast rule.
That being said, we work in a company where virtually all code is reviewed.
Long winded comments introduce maintainability issues, since the comment can diverge from the working in time.
Extensive spelling mistakes in them certainly becomes irritating, especially since there are plenty of good editors available with spell checking included.
That just points to sloppiness.
Not bothering to use a tool's features shows no pursuit of excellence and that certainly places doubts on the rest.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116734</id>
	<title>Non-native English speakers</title>
	<author>Anonymous</author>
	<datestamp>1258393440000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>4</modscore>
	<htmltext><p>English is not most people's first language. Be glad they want to write comments in English at all.</p></htmltext>
<tokenext>English is not most people 's first language .
Be glad they want to write comments in English at all .</tokentext>
<sentencetext>English is not most people's first language.
Be glad they want to write comments in English at all.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30128022</id>
	<title>Mark this guy as a twit</title>
	<author>Anonymous</author>
	<datestamp>1258467900000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>An idiots argument.<br>I feel dumber having read this.<br>If its false for one case its false for all...hey look below a false case.<br>Yeah OP marked as a twit.<nobr> <wbr></nobr>/* This is a for loop */<br>if (a == b)<br>
&nbsp; &nbsp; &nbsp; {<br>
&nbsp; &nbsp; &nbsp; DoSomething();<br>
&nbsp; &nbsp; &nbsp; }<nobr> <wbr></nobr>/* This here fer loop calls DoSomething MAX\_INDEX     */<nobr> <wbr></nobr>/* times to init all linked elements to array dependents. */<br>for (int i=0; i  MAX\_INDEX; i++)<br>
&nbsp; &nbsp; &nbsp; {<br>
&nbsp; &nbsp; &nbsp; DoSomething();<br>
&nbsp; &nbsp; &nbsp; }</p></htmltext>
<tokenext>An idiots argument.I feel dumber having read this.If its false for one case its false for all...hey look below a false case.Yeah OP marked as a twit .
/ * This is a for loop * /if ( a = = b )       {       DoSomething ( ) ;       } / * This here fer loop calls DoSomething MAX \ _INDEX * / / * times to init all linked elements to array dependents .
* /for ( int i = 0 ; i MAX \ _INDEX ; i + + )       {       DoSomething ( ) ;       }</tokentext>
<sentencetext>An idiots argument.I feel dumber having read this.If its false for one case its false for all...hey look below a false case.Yeah OP marked as a twit.
/* This is a for loop */if (a == b)
      {
      DoSomething();
      } /* This here fer loop calls DoSomething MAX\_INDEX     */ /* times to init all linked elements to array dependents.
*/for (int i=0; i  MAX\_INDEX; i++)
      {
      DoSomething();
      }</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117056</id>
	<title>Re:// teh code is obvius</title>
	<author>JohnnyLocust</author>
	<datestamp>1258394520000</datestamp>
	<modclass>Funny</modclass>
	<modscore>2</modscore>
	<htmltext>/* Comments are for wimps. */</htmltext>
<tokenext>/ * Comments are for wimps .
* /</tokentext>
<sentencetext>/* Comments are for wimps.
*/</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116670</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120294</id>
	<title>Re:Existence of Comments</title>
	<author>Anonymous</author>
	<datestamp>1258404540000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext>Bah.  Perl looks like Bruce Schneier shat on your keyboard and it happened to compile.</htmltext>
<tokenext>Bah .
Perl looks like Bruce Schneier shat on your keyboard and it happened to compile .</tokentext>
<sentencetext>Bah.
Perl looks like Bruce Schneier shat on your keyboard and it happened to compile.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116872</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118182</id>
	<title>Re:Job Security</title>
	<author>plague3106</author>
	<datestamp>1258398060000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Why are you dealing with this nonsense?  Your dev. environment can't reformat the code for you automatically?</p></htmltext>
<tokenext>Why are you dealing with this nonsense ?
Your dev .
environment ca n't reformat the code for you automatically ?</tokentext>
<sentencetext>Why are you dealing with this nonsense?
Your dev.
environment can't reformat the code for you automatically?</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117098</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116982</id>
	<title>Practical application of comments</title>
	<author>dkh2</author>
	<datestamp>1258394220000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>The group I work with views code commentary as a requirement of the job of the go-coder.</p><p>Initial development of a new method (procedure, function, whatever a discreet unit of functional code is called in your language of choice) begins with inclusion of a summary comment of the specification. This puts the spec where the developer is working and can use it.  This comment block gets tweaked and resequenced to fit the logical and technical demands of delivering the specified result and to segregate each logical step into distinct comments.</p><p>Once functional code has been implemented and unit tested the comments are reduced or eliminated along side a focused and targeted walk through variable and method names to produce final code that is as self documenting as possible.</p><p>Comments remaining in the code are there as bookmarks/breadcrumbs, or provide insight into why a particular logical approach was taken.  As for the variant spellings issue - we are a small shop in the U.S. so we tell our international employees that we use EN-US spellings.  ("There is no 'U' in 'honor.' and it's 'aluminum' (4 syllables) not 'aluminium' (5 syllables).")</p></htmltext>
<tokenext>The group I work with views code commentary as a requirement of the job of the go-coder.Initial development of a new method ( procedure , function , whatever a discreet unit of functional code is called in your language of choice ) begins with inclusion of a summary comment of the specification .
This puts the spec where the developer is working and can use it .
This comment block gets tweaked and resequenced to fit the logical and technical demands of delivering the specified result and to segregate each logical step into distinct comments.Once functional code has been implemented and unit tested the comments are reduced or eliminated along side a focused and targeted walk through variable and method names to produce final code that is as self documenting as possible.Comments remaining in the code are there as bookmarks/breadcrumbs , or provide insight into why a particular logical approach was taken .
As for the variant spellings issue - we are a small shop in the U.S. so we tell our international employees that we use EN-US spellings .
( " There is no 'U ' in 'honor .
' and it 's 'aluminum ' ( 4 syllables ) not 'aluminium ' ( 5 syllables ) .
" )</tokentext>
<sentencetext>The group I work with views code commentary as a requirement of the job of the go-coder.Initial development of a new method (procedure, function, whatever a discreet unit of functional code is called in your language of choice) begins with inclusion of a summary comment of the specification.
This puts the spec where the developer is working and can use it.
This comment block gets tweaked and resequenced to fit the logical and technical demands of delivering the specified result and to segregate each logical step into distinct comments.Once functional code has been implemented and unit tested the comments are reduced or eliminated along side a focused and targeted walk through variable and method names to produce final code that is as self documenting as possible.Comments remaining in the code are there as bookmarks/breadcrumbs, or provide insight into why a particular logical approach was taken.
As for the variant spellings issue - we are a small shop in the U.S. so we tell our international employees that we use EN-US spellings.
("There is no 'U' in 'honor.
' and it's 'aluminum' (4 syllables) not 'aluminium' (5 syllables).
")</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120210</id>
	<title>Re:The comment may also be complex..</title>
	<author>uncqual</author>
	<datestamp>1258404300000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>It's good to see a poster who worked on the <a href="http://sunnyday.mit.edu/papers/therac.pdf" title="mit.edu">Therac-25</a> [mit.edu] - we don't get many of those here anymore.</htmltext>
<tokenext>It 's good to see a poster who worked on the Therac-25 [ mit.edu ] - we do n't get many of those here anymore .</tokentext>
<sentencetext>It's good to see a poster who worked on the Therac-25 [mit.edu] - we don't get many of those here anymore.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116726</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30119428</id>
	<title>I write mine in swahili</title>
	<author>Anonymous</author>
	<datestamp>1258401840000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I write my comments in swahili, if the comment was hard to write, it should be hard to read.</p></htmltext>
<tokenext>I write my comments in swahili , if the comment was hard to write , it should be hard to read .</tokentext>
<sentencetext>I write my comments in swahili, if the comment was hard to write, it should be hard to read.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116734</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120712</id>
	<title>Re:Non-native English speakers</title>
	<author>Anonymous</author>
	<datestamp>1258362900000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>I'd rather they wrote well in their own language, rather than in a pidgin version of mine.</p></htmltext>
<tokenext>I 'd rather they wrote well in their own language , rather than in a pidgin version of mine .</tokentext>
<sentencetext>I'd rather they wrote well in their own language, rather than in a pidgin version of mine.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116734</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30133606</id>
	<title>Re:I'm an expert!</title>
	<author>Cederic</author>
	<datestamp>1258491480000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Surely his implementation merely ensured the donkey would be kicked whether it needed it or not?</p></htmltext>
<tokenext>Surely his implementation merely ensured the donkey would be kicked whether it needed it or not ?</tokentext>
<sentencetext>Surely his implementation merely ensured the donkey would be kicked whether it needed it or not?</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118368</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30123032</id>
	<title>Re:The comment may also be complex..</title>
	<author>nschubach</author>
	<datestamp>1258371900000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Unit tests are only for consistency... the test could be totally wrong and supply irrelevant information, but it will work like the last copy.  Congrats to backwards compatibility.</p></htmltext>
<tokenext>Unit tests are only for consistency... the test could be totally wrong and supply irrelevant information , but it will work like the last copy .
Congrats to backwards compatibility .</tokentext>
<sentencetext>Unit tests are only for consistency... the test could be totally wrong and supply irrelevant information, but it will work like the last copy.
Congrats to backwards compatibility.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117134</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116868</id>
	<title>I agree, with reservations</title>
	<author>JustNiz</author>
	<datestamp>1258393800000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>4</modscore>
	<htmltext><p>From 30 years of developing software, I've found time and time again that it actually does seem that people who don't know or care about the difference between "their" and "they're" are also too sloppy, unintelligent or just not anal enough to write clean, supportable and robust code.</p><p>However I feel we do need to make more allowance than the article's author did for people who did not learn English as a first language.</p></htmltext>
<tokenext>From 30 years of developing software , I 've found time and time again that it actually does seem that people who do n't know or care about the difference between " their " and " they 're " are also too sloppy , unintelligent or just not anal enough to write clean , supportable and robust code.However I feel we do need to make more allowance than the article 's author did for people who did not learn English as a first language .</tokentext>
<sentencetext>From 30 years of developing software, I've found time and time again that it actually does seem that people who don't know or care about the difference between "their" and "they're" are also too sloppy, unintelligent or just not anal enough to write clean, supportable and robust code.However I feel we do need to make more allowance than the article's author did for people who did not learn English as a first language.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118106</id>
	<title>I agree...</title>
	<author>Chris.Nelson</author>
	<datestamp>1258397940000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I've also heard (I can't remember where), "If the code and the comments disagree, they are both wrong."</p></htmltext>
<tokenext>I 've also heard ( I ca n't remember where ) , " If the code and the comments disagree , they are both wrong .
"</tokentext>
<sentencetext>I've also heard (I can't remember where), "If the code and the comments disagree, they are both wrong.
"</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120258</id>
	<title>Re:Here's an idea</title>
	<author>rgviza</author>
	<datestamp>1258404420000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>another problem with comments is the functionality changes and nobody updates the comments, so a developer coming in later will get the wrong idea and be even more confused than if the comments weren't there leading to more head-scratching.</p><p>Sometimes comments are worse than useless.</p></htmltext>
<tokenext>another problem with comments is the functionality changes and nobody updates the comments , so a developer coming in later will get the wrong idea and be even more confused than if the comments were n't there leading to more head-scratching.Sometimes comments are worse than useless .</tokentext>
<sentencetext>another problem with comments is the functionality changes and nobody updates the comments, so a developer coming in later will get the wrong idea and be even more confused than if the comments weren't there leading to more head-scratching.Sometimes comments are worse than useless.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117812</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116670</id>
	<title>// teh code is obvius</title>
	<author>tedgyz</author>
	<datestamp>1258393200000</datestamp>
	<modclass>Funny</modclass>
	<modscore>4</modscore>
	<htmltext><p>Comments are for wimps.</p></htmltext>
<tokenext>Comments are for wimps .</tokentext>
<sentencetext>Comments are for wimps.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30133684</id>
	<title>Re:I agree, with reservations</title>
	<author>Cederic</author>
	<datestamp>1258448580000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>The point of the article, and of the person you replied to (or should that be 'to whom you replied') is that people that write high quality code will instinctively care about, know or just get right the difference between their, there and they're.</p><p>I've had enough experience (without joining the pissing match) hitting tough deadlines to know that no comment is better than a wrong comment, and my brain gets upset with poor grammar/spelling in comments.</p><p>You're right that productivity is impacted by grammar. Alas the evidence appears to be that companies benefit from higher productivity if their staff care about it.</p></htmltext>
<tokenext>The point of the article , and of the person you replied to ( or should that be 'to whom you replied ' ) is that people that write high quality code will instinctively care about , know or just get right the difference between their , there and they 're.I 've had enough experience ( without joining the pissing match ) hitting tough deadlines to know that no comment is better than a wrong comment , and my brain gets upset with poor grammar/spelling in comments.You 're right that productivity is impacted by grammar .
Alas the evidence appears to be that companies benefit from higher productivity if their staff care about it .</tokentext>
<sentencetext>The point of the article, and of the person you replied to (or should that be 'to whom you replied') is that people that write high quality code will instinctively care about, know or just get right the difference between their, there and they're.I've had enough experience (without joining the pissing match) hitting tough deadlines to know that no comment is better than a wrong comment, and my brain gets upset with poor grammar/spelling in comments.You're right that productivity is impacted by grammar.
Alas the evidence appears to be that companies benefit from higher productivity if their staff care about it.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117648</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117576</id>
	<title>Coding Drunk</title>
	<author>twmcneil</author>
	<datestamp>1258396260000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>2</modscore>
	<htmltext>I usually comment much more (and need to) when I'm coding drunk.  That also explains the excessive use of the word "Fuck" in my comments.  But even drunk, I know the difference between their, there and they're.</htmltext>
<tokenext>I usually comment much more ( and need to ) when I 'm coding drunk .
That also explains the excessive use of the word " Fuck " in my comments .
But even drunk , I know the difference between their , there and they 're .</tokentext>
<sentencetext>I usually comment much more (and need to) when I'm coding drunk.
That also explains the excessive use of the word "Fuck" in my comments.
But even drunk, I know the difference between their, there and they're.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120320</id>
	<title>Re:The comment may also be complex..</title>
	<author>uncqual</author>
	<datestamp>1258404600000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><blockquote><div><p>Apparently there *is* a dark side to a high-quality unit test suite...</p></div></blockquote><p>How true... I worked at a place where one group used agile methods (sort of). It was amusing to watch them argue to a group that their software interfaced with that "it can't be our problem, it passed unit tests". d'oh! (Of course, it was their problem - their unit tests hadn't, and couldn't, have covered everything - a code review probably would have caught it though).</p></div>
	</htmltext>
<tokenext>Apparently there * is * a dark side to a high-quality unit test suite...How true... I worked at a place where one group used agile methods ( sort of ) .
It was amusing to watch them argue to a group that their software interfaced with that " it ca n't be our problem , it passed unit tests " .
d'oh ! ( Of course , it was their problem - their unit tests had n't , and could n't , have covered everything - a code review probably would have caught it though ) .</tokentext>
<sentencetext>Apparently there *is* a dark side to a high-quality unit test suite...How true... I worked at a place where one group used agile methods (sort of).
It was amusing to watch them argue to a group that their software interfaced with that "it can't be our problem, it passed unit tests".
d'oh! (Of course, it was their problem - their unit tests hadn't, and couldn't, have covered everything - a code review probably would have caught it though).
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117028</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118804</id>
	<title>Ugly code and ugly comments</title>
	<author>Anonymous</author>
	<datestamp>1258400040000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>When I get board and go looking for bugs the first thing I do is look at comments.  Writing styles or signatures of the clueless developers on our team serve as beacons bugs are hopelessly beckoned to.  Its not the quality of the comment itself but the person behind it that is most interesting.</p><p>Comments starting with "This fixes" sometimes have a tendancy of breaking other things or still failing to cover the entire problem space.  Its mostly I believe those who waste space bragging about what they fixed tend to be noobies who to quote yoda still have much to learn.</p><p>Comments "blaiming the compiler" bring up imagary of smart little critters laughing at the dumb humans who can't squish them and always contain bugs.</p><p>Comments with profanity and insults are written by people who couldn't think their way out of an open window.  They are also at risk of going postal at some point in the future.   When you fix their code do yourself a favor and don't tell them about it.  Use an alias when submitting changes to their work in your revision control system.</p><p>Comments with funny jokes are always written by genius talent.  You should not waste your time and just assume the problem is elsewhere.</p><p>Comments with apologies (sorry..et al) are often a reflection of a bad form of laziness OR developers who have accepted that everything anyone will ever do is crap and persistantly strive to produce less smellier crap.  Its a mixed bag - the bug load and realitve quality of such code depends on who wrote it.</p><p>Use of bad english, mispellings..etc I have never really found a usable signal in.  It could be that english is not the native language of some or people rightfully want to get crap done and invest no time in spell checking comments.</p></div>
	</htmltext>
<tokenext>When I get board and go looking for bugs the first thing I do is look at comments .
Writing styles or signatures of the clueless developers on our team serve as beacons bugs are hopelessly beckoned to .
Its not the quality of the comment itself but the person behind it that is most interesting.Comments starting with " This fixes " sometimes have a tendancy of breaking other things or still failing to cover the entire problem space .
Its mostly I believe those who waste space bragging about what they fixed tend to be noobies who to quote yoda still have much to learn.Comments " blaiming the compiler " bring up imagary of smart little critters laughing at the dumb humans who ca n't squish them and always contain bugs.Comments with profanity and insults are written by people who could n't think their way out of an open window .
They are also at risk of going postal at some point in the future .
When you fix their code do yourself a favor and do n't tell them about it .
Use an alias when submitting changes to their work in your revision control system.Comments with funny jokes are always written by genius talent .
You should not waste your time and just assume the problem is elsewhere.Comments with apologies ( sorry..et al ) are often a reflection of a bad form of laziness OR developers who have accepted that everything anyone will ever do is crap and persistantly strive to produce less smellier crap .
Its a mixed bag - the bug load and realitve quality of such code depends on who wrote it.Use of bad english , mispellings..etc I have never really found a usable signal in .
It could be that english is not the native language of some or people rightfully want to get crap done and invest no time in spell checking comments .</tokentext>
<sentencetext>When I get board and go looking for bugs the first thing I do is look at comments.
Writing styles or signatures of the clueless developers on our team serve as beacons bugs are hopelessly beckoned to.
Its not the quality of the comment itself but the person behind it that is most interesting.Comments starting with "This fixes" sometimes have a tendancy of breaking other things or still failing to cover the entire problem space.
Its mostly I believe those who waste space bragging about what they fixed tend to be noobies who to quote yoda still have much to learn.Comments "blaiming the compiler" bring up imagary of smart little critters laughing at the dumb humans who can't squish them and always contain bugs.Comments with profanity and insults are written by people who couldn't think their way out of an open window.
They are also at risk of going postal at some point in the future.
When you fix their code do yourself a favor and don't tell them about it.
Use an alias when submitting changes to their work in your revision control system.Comments with funny jokes are always written by genius talent.
You should not waste your time and just assume the problem is elsewhere.Comments with apologies (sorry..et al) are often a reflection of a bad form of laziness OR developers who have accepted that everything anyone will ever do is crap and persistantly strive to produce less smellier crap.
Its a mixed bag - the bug load and realitve quality of such code depends on who wrote it.Use of bad english, mispellings..etc I have never really found a usable signal in.
It could be that english is not the native language of some or people rightfully want to get crap done and invest no time in spell checking comments.
	</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118070</id>
	<title>Re:T&#228;st&#228; voit hakea sanan kategorian (av</title>
	<author>TeknoHog</author>
	<datestamp>1258397760000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>
"Here you can find the category of the word"
</p><p>
I'm sure somebody will try to correct me in that "hakea" actually means "fetch" or "search", but in this case I find "find" more appropriate. The word "avain" means "key" and it is probably related to explaining the idea of "category".
</p></htmltext>
<tokenext>" Here you can find the category of the word " I 'm sure somebody will try to correct me in that " hakea " actually means " fetch " or " search " , but in this case I find " find " more appropriate .
The word " avain " means " key " and it is probably related to explaining the idea of " category " .</tokentext>
<sentencetext>
"Here you can find the category of the word"

I'm sure somebody will try to correct me in that "hakea" actually means "fetch" or "search", but in this case I find "find" more appropriate.
The word "avain" means "key" and it is probably related to explaining the idea of "category".
</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117196</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117484</id>
	<title>Re:I'm an expert!</title>
	<author>Nerdfest</author>
	<datestamp>1258396080000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>kick\_ass() should be specified in an interface. Chuck Norris is the implementation.</htmltext>
<tokenext>kick \ _ass ( ) should be specified in an interface .
Chuck Norris is the implementation .</tokentext>
<sentencetext>kick\_ass() should be specified in an interface.
Chuck Norris is the implementation.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116778</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117152</id>
	<title>Native English Speaker</title>
	<author>binaryartist</author>
	<datestamp>1258395000000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>What if the person who wrote grammatically incorrect comments is not a native English speaker? Engligh not fluent, C++ very fluent!</htmltext>
<tokenext>What if the person who wrote grammatically incorrect comments is not a native English speaker ?
Engligh not fluent , C + + very fluent !</tokentext>
<sentencetext>What if the person who wrote grammatically incorrect comments is not a native English speaker?
Engligh not fluent, C++ very fluent!</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120880</id>
	<title>Re:// teh code is obvius</title>
	<author>R3d M3rcury</author>
	<datestamp>1258363620000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>What are these "comments" of which you speak?  These sound intriguing and I'd like to subscribe to your newsletter...</p></htmltext>
<tokenext>What are these " comments " of which you speak ?
These sound intriguing and I 'd like to subscribe to your newsletter.. .</tokentext>
<sentencetext>What are these "comments" of which you speak?
These sound intriguing and I'd like to subscribe to your newsletter...</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116670</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116694</id>
	<title>Sounds right</title>
	<author>TheRaven64</author>
	<datestamp>1258393260000</datestamp>
	<modclass>Funny</modclass>
	<modscore>2</modscore>
	<htmltext><p>It should be obvious what the code is doing just from reading it.  If it isn't, then the code should usually be refactored.  Comments are for explaining why the code is doing that.  If your grammar is poor in the English then it's probably poor in the code too (unless you are not a native speaker).  If you make spelling errors in comments then you probably do in code too.  The compiler will catch some of these, but when you accidentally type the name of an instance variable or a global instead of a local, it won't spot it.  If you're not checking your comments for this kind of error, you're probably not checking your code for it either.  </p><p>
Just as with online comments, poor grammar displays a lack of care.  Hopefully, more people will be reading your comments than will be writing them.  A little effort in writing them can save a lot of effort in reading them.  If someone on the Internet thinks that their time is worth so much more than their readers' time then that just makes them an asshat[1].  If a programmer thinks his or her time is so much more valuable than that of people maintaining the code then he or she is a terrible programmer.

</p><p>[1] I am fully aware of the universal law that means that, by writing this, my post will have a significantly above average number of typos.  Please be nice...</p></htmltext>
<tokenext>It should be obvious what the code is doing just from reading it .
If it is n't , then the code should usually be refactored .
Comments are for explaining why the code is doing that .
If your grammar is poor in the English then it 's probably poor in the code too ( unless you are not a native speaker ) .
If you make spelling errors in comments then you probably do in code too .
The compiler will catch some of these , but when you accidentally type the name of an instance variable or a global instead of a local , it wo n't spot it .
If you 're not checking your comments for this kind of error , you 're probably not checking your code for it either .
Just as with online comments , poor grammar displays a lack of care .
Hopefully , more people will be reading your comments than will be writing them .
A little effort in writing them can save a lot of effort in reading them .
If someone on the Internet thinks that their time is worth so much more than their readers ' time then that just makes them an asshat [ 1 ] .
If a programmer thinks his or her time is so much more valuable than that of people maintaining the code then he or she is a terrible programmer .
[ 1 ] I am fully aware of the universal law that means that , by writing this , my post will have a significantly above average number of typos .
Please be nice.. .</tokentext>
<sentencetext>It should be obvious what the code is doing just from reading it.
If it isn't, then the code should usually be refactored.
Comments are for explaining why the code is doing that.
If your grammar is poor in the English then it's probably poor in the code too (unless you are not a native speaker).
If you make spelling errors in comments then you probably do in code too.
The compiler will catch some of these, but when you accidentally type the name of an instance variable or a global instead of a local, it won't spot it.
If you're not checking your comments for this kind of error, you're probably not checking your code for it either.
Just as with online comments, poor grammar displays a lack of care.
Hopefully, more people will be reading your comments than will be writing them.
A little effort in writing them can save a lot of effort in reading them.
If someone on the Internet thinks that their time is worth so much more than their readers' time then that just makes them an asshat[1].
If a programmer thinks his or her time is so much more valuable than that of people maintaining the code then he or she is a terrible programmer.
[1] I am fully aware of the universal law that means that, by writing this, my post will have a significantly above average number of typos.
Please be nice...</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117028</id>
	<title>Re:The comment may also be complex..</title>
	<author>Anonymous</author>
	<datestamp>1258394400000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>5</modscore>
	<htmltext><p><i>In your example, the code you got working for -x, +y may not have been "Good", but if it passes the Unit Tests, then how is it really bad?</i></p><p>How is it bad??  Christ, the metric for "good" code isn't that it simply "works".  It also needs to be readable, comprehensible, and maintainable.  If you can't understand how your own code works, it's bloody obvious it fails on at least one of those metrics.</p><p>Besides which, unless you are 100\% positive that your unit test covers *all* cases, the fact that your code passes tells you nothing about it's correctness.</p><p>You know, back in my university days, we used to scoff at the morons in the labs who would, quite literally, randomly hack their projects until they worked.  I never dreamed that some would consider that a valid development methodology out in the real world.  Apparently there *is* a dark side to a high-quality unit test suite... it gives idiots a false sense of security and justifies their idiotic development practices.</p></htmltext>
<tokenext>In your example , the code you got working for -x , + y may not have been " Good " , but if it passes the Unit Tests , then how is it really bad ? How is it bad ? ?
Christ , the metric for " good " code is n't that it simply " works " .
It also needs to be readable , comprehensible , and maintainable .
If you ca n't understand how your own code works , it 's bloody obvious it fails on at least one of those metrics.Besides which , unless you are 100 \ % positive that your unit test covers * all * cases , the fact that your code passes tells you nothing about it 's correctness.You know , back in my university days , we used to scoff at the morons in the labs who would , quite literally , randomly hack their projects until they worked .
I never dreamed that some would consider that a valid development methodology out in the real world .
Apparently there * is * a dark side to a high-quality unit test suite... it gives idiots a false sense of security and justifies their idiotic development practices .</tokentext>
<sentencetext>In your example, the code you got working for -x, +y may not have been "Good", but if it passes the Unit Tests, then how is it really bad?How is it bad??
Christ, the metric for "good" code isn't that it simply "works".
It also needs to be readable, comprehensible, and maintainable.
If you can't understand how your own code works, it's bloody obvious it fails on at least one of those metrics.Besides which, unless you are 100\% positive that your unit test covers *all* cases, the fact that your code passes tells you nothing about it's correctness.You know, back in my university days, we used to scoff at the morons in the labs who would, quite literally, randomly hack their projects until they worked.
I never dreamed that some would consider that a valid development methodology out in the real world.
Apparently there *is* a dark side to a high-quality unit test suite... it gives idiots a false sense of security and justifies their idiotic development practices.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116726</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30119804</id>
	<title>The reality...</title>
	<author>TemporalBeing</author>
	<datestamp>1258402980000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>2</modscore>
	<htmltext>The reality is that comments tell what the code <b>ought</b> to do; while the code only shows what it <b>actually does</b>.
<br> <br>
I tend to write comments of varying lengths - sometimes, writing longer comments not for my own benefit, but for the benefit of the next coder - someone who may or may not have my understanding of the system or code; and more likely than not, either won't have the time to learn the code 100\% in-and-out, or are not up to the same par. So sometimes, I will write a large comment block on an important thing in the code - so that <i>they</i> (whoever they are) <i>will</i> be able to understand it quite quickly. However, that is (as it should be) quite few and far between; sometimes documenting complex logic from elsewhere in the system that I have no control over but the programmer needs to be able to understand.
<br> <br>
Of course, there is also the typical PHB managers who evaluate their programmers based on LOC, SLOC, and CLOC (LOC = SLOC + CLOC), and look for an even distribution of SLOC/CLOC - e.g. SLOC/CLOC = 1. In some cases that is good; but in most it is not.
<br> <br>
All in all, you can't tell how good the program is by just general comments or comment analysis.
<br> <br>
BUT if you are sloppy in your comments (grammar, spelling, etc.), you have probably been sloppy in your code. To that end, I do very well agree with the article.
<br> <br>
P.S. BTW, I've been in 3 positions where I have replaced people. One fired; one died; and one quit. In two of those three, the original developer was no longer available for inquiry; in the third, it was possible but not easy and only for a short time after he left.</htmltext>
<tokenext>The reality is that comments tell what the code ought to do ; while the code only shows what it actually does .
I tend to write comments of varying lengths - sometimes , writing longer comments not for my own benefit , but for the benefit of the next coder - someone who may or may not have my understanding of the system or code ; and more likely than not , either wo n't have the time to learn the code 100 \ % in-and-out , or are not up to the same par .
So sometimes , I will write a large comment block on an important thing in the code - so that they ( whoever they are ) will be able to understand it quite quickly .
However , that is ( as it should be ) quite few and far between ; sometimes documenting complex logic from elsewhere in the system that I have no control over but the programmer needs to be able to understand .
Of course , there is also the typical PHB managers who evaluate their programmers based on LOC , SLOC , and CLOC ( LOC = SLOC + CLOC ) , and look for an even distribution of SLOC/CLOC - e.g .
SLOC/CLOC = 1 .
In some cases that is good ; but in most it is not .
All in all , you ca n't tell how good the program is by just general comments or comment analysis .
BUT if you are sloppy in your comments ( grammar , spelling , etc .
) , you have probably been sloppy in your code .
To that end , I do very well agree with the article .
P.S. BTW , I 've been in 3 positions where I have replaced people .
One fired ; one died ; and one quit .
In two of those three , the original developer was no longer available for inquiry ; in the third , it was possible but not easy and only for a short time after he left .</tokentext>
<sentencetext>The reality is that comments tell what the code ought to do; while the code only shows what it actually does.
I tend to write comments of varying lengths - sometimes, writing longer comments not for my own benefit, but for the benefit of the next coder - someone who may or may not have my understanding of the system or code; and more likely than not, either won't have the time to learn the code 100\% in-and-out, or are not up to the same par.
So sometimes, I will write a large comment block on an important thing in the code - so that they (whoever they are) will be able to understand it quite quickly.
However, that is (as it should be) quite few and far between; sometimes documenting complex logic from elsewhere in the system that I have no control over but the programmer needs to be able to understand.
Of course, there is also the typical PHB managers who evaluate their programmers based on LOC, SLOC, and CLOC (LOC = SLOC + CLOC), and look for an even distribution of SLOC/CLOC - e.g.
SLOC/CLOC = 1.
In some cases that is good; but in most it is not.
All in all, you can't tell how good the program is by just general comments or comment analysis.
BUT if you are sloppy in your comments (grammar, spelling, etc.
), you have probably been sloppy in your code.
To that end, I do very well agree with the article.
P.S. BTW, I've been in 3 positions where I have replaced people.
One fired; one died; and one quit.
In two of those three, the original developer was no longer available for inquiry; in the third, it was possible but not easy and only for a short time after he left.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30127478</id>
	<title>I hate this line of thinking</title>
	<author>jabjoe</author>
	<datestamp>1258459800000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>As a dyslexic I resent the idea my spelling is related to the quality of my code. Maybe because of my dyslexia, I have feelings about over commenting. If you want to write a book, write a book, but don't write it in your code! What I can't stand is when I can't read the code for the comments, or when the comments are wrong or pointless, i.e. the variable/function name tells you already or code and comment don't match. You end up with two sources in the same file, one real one, one for humans, why not aim for one for both? Two is asking for trouble. If you must write a lot of comments, please put it above the function so it's out the way. I feel software is organic, it evolves, it's farmed as much as designed. It quickly gets beyond what we can design. By trying to formalize it, you're sucking all the joy out and slowing down development and removing the creativity. There is a balance, you go one way it's crazy bat shit, you go the other and is slow and everyone leaves for something more fun because life is too short for such drudgery. Write as clearly as you can, comment where it's needed, automate what testing you can (without slowing everything to a point both users and developers get frustrated), then test it on as many users as you can. We all use programs written like this. I've never even seen this perfectly commented code ivory tower types rant about. If there is an open source example please point to it so I can see it. What I see if that when people first start programming, or start in a new language, they comment a lot, but that dies off as reading the code becomes easier. The other group who comment a lot are ivory tower types, and some are good, some are bad, so I don't think it helps them. I would rather good code without comments, then bad code with lots of comments.</htmltext>
<tokenext>As a dyslexic I resent the idea my spelling is related to the quality of my code .
Maybe because of my dyslexia , I have feelings about over commenting .
If you want to write a book , write a book , but do n't write it in your code !
What I ca n't stand is when I ca n't read the code for the comments , or when the comments are wrong or pointless , i.e .
the variable/function name tells you already or code and comment do n't match .
You end up with two sources in the same file , one real one , one for humans , why not aim for one for both ?
Two is asking for trouble .
If you must write a lot of comments , please put it above the function so it 's out the way .
I feel software is organic , it evolves , it 's farmed as much as designed .
It quickly gets beyond what we can design .
By trying to formalize it , you 're sucking all the joy out and slowing down development and removing the creativity .
There is a balance , you go one way it 's crazy bat shit , you go the other and is slow and everyone leaves for something more fun because life is too short for such drudgery .
Write as clearly as you can , comment where it 's needed , automate what testing you can ( without slowing everything to a point both users and developers get frustrated ) , then test it on as many users as you can .
We all use programs written like this .
I 've never even seen this perfectly commented code ivory tower types rant about .
If there is an open source example please point to it so I can see it .
What I see if that when people first start programming , or start in a new language , they comment a lot , but that dies off as reading the code becomes easier .
The other group who comment a lot are ivory tower types , and some are good , some are bad , so I do n't think it helps them .
I would rather good code without comments , then bad code with lots of comments .</tokentext>
<sentencetext>As a dyslexic I resent the idea my spelling is related to the quality of my code.
Maybe because of my dyslexia, I have feelings about over commenting.
If you want to write a book, write a book, but don't write it in your code!
What I can't stand is when I can't read the code for the comments, or when the comments are wrong or pointless, i.e.
the variable/function name tells you already or code and comment don't match.
You end up with two sources in the same file, one real one, one for humans, why not aim for one for both?
Two is asking for trouble.
If you must write a lot of comments, please put it above the function so it's out the way.
I feel software is organic, it evolves, it's farmed as much as designed.
It quickly gets beyond what we can design.
By trying to formalize it, you're sucking all the joy out and slowing down development and removing the creativity.
There is a balance, you go one way it's crazy bat shit, you go the other and is slow and everyone leaves for something more fun because life is too short for such drudgery.
Write as clearly as you can, comment where it's needed, automate what testing you can (without slowing everything to a point both users and developers get frustrated), then test it on as many users as you can.
We all use programs written like this.
I've never even seen this perfectly commented code ivory tower types rant about.
If there is an open source example please point to it so I can see it.
What I see if that when people first start programming, or start in a new language, they comment a lot, but that dies off as reading the code becomes easier.
The other group who comment a lot are ivory tower types, and some are good, some are bad, so I don't think it helps them.
I would rather good code without comments, then bad code with lots of comments.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116680</id>
	<title>Well, duh.</title>
	<author>mobby\_6kl</author>
	<datestamp>1258393200000</datestamp>
	<modclass>Funny</modclass>
	<modscore>4</modscore>
	<htmltext><p>That's also why I don't comment my code.</p></htmltext>
<tokenext>That 's also why I do n't comment my code .</tokentext>
<sentencetext>That's also why I don't comment my code.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117014</id>
	<title>Why doesn't Literate Programming catch on?</title>
	<author>WillAdams</author>
	<datestamp>1258394340000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>There's a terrible irony in Donald Knuth feeling that it's an even more important development than TeX, yet outside of the TeX world, almost no one uses it:</p><p><a href="http://www.literateprogramming.com/" title="literateprogramming.com">http://www.literateprogramming.com/</a> [literateprogramming.com]</p><p>William</p></htmltext>
<tokenext>There 's a terrible irony in Donald Knuth feeling that it 's an even more important development than TeX , yet outside of the TeX world , almost no one uses it : http : //www.literateprogramming.com/ [ literateprogramming.com ] William</tokentext>
<sentencetext>There's a terrible irony in Donald Knuth feeling that it's an even more important development than TeX, yet outside of the TeX world, almost no one uses it:http://www.literateprogramming.com/ [literateprogramming.com]William</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117586</id>
	<title>Re:Nonesense</title>
	<author>clone53421</author>
	<datestamp>1258396260000</datestamp>
	<modclass>Funny</modclass>
	<modscore>3</modscore>
	<htmltext><p><div class="quote"><p>In addition, some of us write comments first and then fill in the code. <strong>Often, in fact quite often, the code evolves past what the comments say.</strong></p> </div><p>You. Are. Doing. It. Wrong.</p><p>If the code evolves, fix the comments. Unless you're deliberately trying to confuse the next person who gets the pleasure of maintaining your code...</p></div>
	</htmltext>
<tokenext>In addition , some of us write comments first and then fill in the code .
Often , in fact quite often , the code evolves past what the comments say .
You. Are .
Doing. It .
Wrong.If the code evolves , fix the comments .
Unless you 're deliberately trying to confuse the next person who gets the pleasure of maintaining your code.. .</tokentext>
<sentencetext>In addition, some of us write comments first and then fill in the code.
Often, in fact quite often, the code evolves past what the comments say.
You. Are.
Doing. It.
Wrong.If the code evolves, fix the comments.
Unless you're deliberately trying to confuse the next person who gets the pleasure of maintaining your code...
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116666</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116716</id>
	<title>10 PRIN "WTF"</title>
	<author>mcgrew</author>
	<datestamp>1258393380000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>This seems like a no-brainer to me. Sloppy people are sloppy and stupid people are stupid, how is this not evident? The only difference is that a lot of bugs are obvuous, when the code fails to run or runs is an unexpected way, while the bad comments won't stop the code from working, only from being understood.</p><p>There are a lot of times I'll see slashdot comments like "you might loose your mind" and I think "I hope that guy's not a programmer." Loosing your mind is quite a different thing than losing it, and like some software bugs might not be evident the first time the code is run.</p></htmltext>
<tokenext>This seems like a no-brainer to me .
Sloppy people are sloppy and stupid people are stupid , how is this not evident ?
The only difference is that a lot of bugs are obvuous , when the code fails to run or runs is an unexpected way , while the bad comments wo n't stop the code from working , only from being understood.There are a lot of times I 'll see slashdot comments like " you might loose your mind " and I think " I hope that guy 's not a programmer .
" Loosing your mind is quite a different thing than losing it , and like some software bugs might not be evident the first time the code is run .</tokentext>
<sentencetext>This seems like a no-brainer to me.
Sloppy people are sloppy and stupid people are stupid, how is this not evident?
The only difference is that a lot of bugs are obvuous, when the code fails to run or runs is an unexpected way, while the bad comments won't stop the code from working, only from being understood.There are a lot of times I'll see slashdot comments like "you might loose your mind" and I think "I hope that guy's not a programmer.
" Loosing your mind is quite a different thing than losing it, and like some software bugs might not be evident the first time the code is run.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116796</id>
	<title>Job Security</title>
	<author>Mekkah</author>
	<datestamp>1258393560000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>I barely comment; JOB Security baby... <br> <br>I do however keep a personal notes file of the few items I find interesting, or harder to work out; JUST in case I can't remember or tie together wtf I was doing.</htmltext>
<tokenext>I barely comment ; JOB Security baby... I do however keep a personal notes file of the few items I find interesting , or harder to work out ; JUST in case I ca n't remember or tie together wtf I was doing .</tokentext>
<sentencetext>I barely comment; JOB Security baby...  I do however keep a personal notes file of the few items I find interesting, or harder to work out; JUST in case I can't remember or tie together wtf I was doing.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118426</id>
	<title>Re:Comments are for future maintainers</title>
	<author>TheGreatOrangePeel</author>
	<datestamp>1258398780000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><blockquote><div><p>i += 4;<nobr> <wbr></nobr>/* Increment i by 4 */ BAD comment</p><p>i += 4;<nobr> <wbr></nobr>/* Ignore the first 4 fields */ okay</p><p>i += 4;<nobr> <wbr></nobr>/* Ignore the first 4 billing fields preceding payment info. */ Better - describes what is ignored.</p><p>i += 4;<nobr> <wbr></nobr>/* Ignore the first 4 billPayChk() billing fields preceding payment info. */ Best</p></div> </blockquote><p>Having been the last step in a 4 tier support team for years, I've seen my fair share of bad comments in code (oh, the number of times I've wanted to utter, "no $\%!7, Sherlock" while debugging). The most helpful comments skipped entirely the WHAT the code was doing and went straight to the why and pointed me to more info. Info is sometimes an old support log, a technical document or another place in the code. Generally speaking, comments like this can save hours of debugging/troubleshooting an issue found by users in the field.</p></div>
	</htmltext>
<tokenext>i + = 4 ; / * Increment i by 4 * / BAD commenti + = 4 ; / * Ignore the first 4 fields * / okayi + = 4 ; / * Ignore the first 4 billing fields preceding payment info .
* / Better - describes what is ignored.i + = 4 ; / * Ignore the first 4 billPayChk ( ) billing fields preceding payment info .
* / Best Having been the last step in a 4 tier support team for years , I 've seen my fair share of bad comments in code ( oh , the number of times I 've wanted to utter , " no $ \ % ! 7 , Sherlock " while debugging ) .
The most helpful comments skipped entirely the WHAT the code was doing and went straight to the why and pointed me to more info .
Info is sometimes an old support log , a technical document or another place in the code .
Generally speaking , comments like this can save hours of debugging/troubleshooting an issue found by users in the field .</tokentext>
<sentencetext>i += 4; /* Increment i by 4 */ BAD commenti += 4; /* Ignore the first 4 fields */ okayi += 4; /* Ignore the first 4 billing fields preceding payment info.
*/ Better - describes what is ignored.i += 4; /* Ignore the first 4 billPayChk() billing fields preceding payment info.
*/ Best Having been the last step in a 4 tier support team for years, I've seen my fair share of bad comments in code (oh, the number of times I've wanted to utter, "no $\%!7, Sherlock" while debugging).
The most helpful comments skipped entirely the WHAT the code was doing and went straight to the why and pointed me to more info.
Info is sometimes an old support log, a technical document or another place in the code.
Generally speaking, comments like this can save hours of debugging/troubleshooting an issue found by users in the field.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117366</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30122986</id>
	<title>Hope you are being ironic...</title>
	<author>Anonymous</author>
	<datestamp>1258371720000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>10 PRIN "WTF"<br>SYNTAX ERROR<nobr> <wbr></nobr>...obvuous...<br>SYNTAX ERROR<nobr> <wbr></nobr>...or runs is an unexpected way...<br>SYNTAX ERROR<nobr> <wbr></nobr>...There are a lot of times I'll see slashdot comments...<br>SYNTAX ERROR</p></htmltext>
<tokenext>10 PRIN " WTF " SYNTAX ERROR ...obvuous...SYNTAX ERROR ...or runs is an unexpected way...SYNTAX ERROR ...There are a lot of times I 'll see slashdot comments...SYNTAX ERROR</tokentext>
<sentencetext>10 PRIN "WTF"SYNTAX ERROR ...obvuous...SYNTAX ERROR ...or runs is an unexpected way...SYNTAX ERROR ...There are a lot of times I'll see slashdot comments...SYNTAX ERROR</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116716</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30124238</id>
	<title>Re:The comment may also be complex..</title>
	<author>Anonymous</author>
	<datestamp>1258378140000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p> <i>It's good to see a poster who worked on the Therac-25</i> </p><p>The article you linked to says Therac-25 failed unit testing (on live units unfortunately).  Clearly this is the opposite of what OP was saying.</p><p>If you want to show OP up, you need to provide an example that works <i>exacly</i> to specification (as Therac-25 clearly did not), yet is in some sense "not good enough" for its intended purpose.</p></htmltext>
<tokenext>It 's good to see a poster who worked on the Therac-25 The article you linked to says Therac-25 failed unit testing ( on live units unfortunately ) .
Clearly this is the opposite of what OP was saying.If you want to show OP up , you need to provide an example that works exacly to specification ( as Therac-25 clearly did not ) , yet is in some sense " not good enough " for its intended purpose .</tokentext>
<sentencetext> It's good to see a poster who worked on the Therac-25 The article you linked to says Therac-25 failed unit testing (on live units unfortunately).
Clearly this is the opposite of what OP was saying.If you want to show OP up, you need to provide an example that works exacly to specification (as Therac-25 clearly did not), yet is in some sense "not good enough" for its intended purpose.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120210</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117706</id>
	<title>Favorite Comments</title>
	<author>digitalPhant0m</author>
	<datestamp>1258396680000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>My two favorites are:<nobr> <wbr></nobr>/* I'm better that you are */<nobr> <wbr></nobr>/* If you can read this, you're too close */</htmltext>
<tokenext>My two favorites are : / * I 'm better that you are * / / * If you can read this , you 're too close * /</tokentext>
<sentencetext>My two favorites are: /* I'm better that you are */ /* If you can read this, you're too close */</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118256</id>
	<title>Rubish</title>
	<author>mce</author>
	<datestamp>1258398300000</datestamp>
	<modclass>Redundant</modclass>
	<modscore>0</modscore>
	<htmltext><p>One simple question regarding spelling/grammar mistakes: What about non-native speakers? Is their code bad just because he or she tends to write  "recieve" instead of "receive" (just one example mistake that is quite common for native Dutch speakers due to bias by his/her mother tongue)? I would hope not... TFA goes as far as to claim that non-natives actually tend to have better English language skills. First of all, I'm not convinced of that as a general rule. But even if it were true, there will always be traps for even those people to fall into unknowingly. What's more, I myself most certainly know about "receive", but even so I get it wrong at least 75\% of the time. I also know that due to "selective blindness" reading the comment afterwards is not enough to catch all of those.
</p><p>
At the other extreme: Back when I was still writing code on a daily basis, I tended to spell check it every so often and fix any mistakes found. Talk about bitf*cking...<nobr> <wbr></nobr>:-) But I fail to see why wasting time on doing that would be a guarantee of proper design.
</p></htmltext>
<tokenext>One simple question regarding spelling/grammar mistakes : What about non-native speakers ?
Is their code bad just because he or she tends to write " recieve " instead of " receive " ( just one example mistake that is quite common for native Dutch speakers due to bias by his/her mother tongue ) ?
I would hope not... TFA goes as far as to claim that non-natives actually tend to have better English language skills .
First of all , I 'm not convinced of that as a general rule .
But even if it were true , there will always be traps for even those people to fall into unknowingly .
What 's more , I myself most certainly know about " receive " , but even so I get it wrong at least 75 \ % of the time .
I also know that due to " selective blindness " reading the comment afterwards is not enough to catch all of those .
At the other extreme : Back when I was still writing code on a daily basis , I tended to spell check it every so often and fix any mistakes found .
Talk about bitf * cking... : - ) But I fail to see why wasting time on doing that would be a guarantee of proper design .</tokentext>
<sentencetext>One simple question regarding spelling/grammar mistakes: What about non-native speakers?
Is their code bad just because he or she tends to write  "recieve" instead of "receive" (just one example mistake that is quite common for native Dutch speakers due to bias by his/her mother tongue)?
I would hope not... TFA goes as far as to claim that non-natives actually tend to have better English language skills.
First of all, I'm not convinced of that as a general rule.
But even if it were true, there will always be traps for even those people to fall into unknowingly.
What's more, I myself most certainly know about "receive", but even so I get it wrong at least 75\% of the time.
I also know that due to "selective blindness" reading the comment afterwards is not enough to catch all of those.
At the other extreme: Back when I was still writing code on a daily basis, I tended to spell check it every so often and fix any mistakes found.
Talk about bitf*cking... :-) But I fail to see why wasting time on doing that would be a guarantee of proper design.
</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120184</id>
	<title>Re:You are not expected to understand this</title>
	<author>rgviza</author>
	<datestamp>1258404240000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>1</modscore>
	<htmltext><p>UNIX is simple, but you have to be a genius to understand the simplicity.</p></htmltext>
<tokenext>UNIX is simple , but you have to be a genius to understand the simplicity .</tokentext>
<sentencetext>UNIX is simple, but you have to be a genius to understand the simplicity.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117090</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116872</id>
	<title>Existence of Comments</title>
	<author>travdaddy</author>
	<datestamp>1258393800000</datestamp>
	<modclass>Funny</modclass>
	<modscore>3</modscore>
	<htmltext>If comments even exist, then the code is ugly.  Code should document itself.<br> <br>
(Any good Perl programmer knows this.)</htmltext>
<tokenext>If comments even exist , then the code is ugly .
Code should document itself .
( Any good Perl programmer knows this .
)</tokentext>
<sentencetext>If comments even exist, then the code is ugly.
Code should document itself.
(Any good Perl programmer knows this.
)</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30119468</id>
	<title>comments are mostly automatic</title>
	<author>anonymousNR</author>
	<datestamp>1258402020000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>I don't know if this is the right thing, but my experience is that I don't comment in general, no matter how complex problem the code solves, but when I recall my code, or go to debug something most of the time I find that I automatically commented something while coding if I was not sure or thought I should at that time to leave a comment there, so in that ratio I have very few comments on my overall code, but also I have had co-workers who ask "what the f**** is this ?" if something I wrote is not clear.</htmltext>
<tokenext>I do n't know if this is the right thing , but my experience is that I do n't comment in general , no matter how complex problem the code solves , but when I recall my code , or go to debug something most of the time I find that I automatically commented something while coding if I was not sure or thought I should at that time to leave a comment there , so in that ratio I have very few comments on my overall code , but also I have had co-workers who ask " what the f * * * * is this ?
" if something I wrote is not clear .</tokentext>
<sentencetext>I don't know if this is the right thing, but my experience is that I don't comment in general, no matter how complex problem the code solves, but when I recall my code, or go to debug something most of the time I find that I automatically commented something while coding if I was not sure or thought I should at that time to leave a comment there, so in that ratio I have very few comments on my overall code, but also I have had co-workers who ask "what the f**** is this ?
" if something I wrote is not clear.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117930</id>
	<title>Re:Sounds right</title>
	<author>Brad Eleven</author>
	<datestamp>1258397340000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>It's a mixed bag, i.e., a blessing and a curse.</p><p>I once inherited 10,000 lines of C source running under SCO Xenix (circa 1990) with exactly two comments, viz "Watch out, this part's tricky," and "Just in case." The code featured one- and two-letter variables, heavy variable reuse, and, yes, GOTOs. The only two parts that were difficult were the custom curses and termio "modules".</p><p>Then there was the stuff written for DOS that had uneven numerical/ASCII conversions.</p><p>Fortunately, my boss understood the problem and gave me time to figure out, fix, and document the source. It was maddening at times, but at the end of that tunnel, I'd learned a lot about several topics that I don't think I could have figured out without having to implement it myself.</p><p>After fixing the bugs, the next task was to implement a new feature. I was very glad I'd taken the time to document everything before adding to the monolith.</p><p>Then my boss gave me 30 days off to make up for the extra hours I'd worked without compensation. He asked that I check voicemail daily and remain available. Meanwhile, they fired my old boss and neglected to tell me. On the day I returned, my new boss stopped me before I'd even reached my desk to tell me that he was my new boss, and that they'd be taking the unauthorized vacation out of my paychecks. I stood there, wondering what it was that held me there, and found nothing. I said, "You know what? I quit." I turned to leave, and the new guy grabbed me and said, "But you're the only one who knows how this thing works, now!"</p><p>I replied, "Exactly," and left. I did not look back. Armed with my recently acquired expertise, I found a job paying exactly twice the salary I had. A month later I heard that they had re-enlisted the contractor who'd written the crappy code. He charged them $1000/day to rewrite my revisions back into his cryptic style in 100 days, then another $100K to re-implement the new features I'd put in.</p><p>The supreme irony is that I'd been hired because they didn't want to shell out for his $50K bid to add the features they wanted. My original boss also wanted FTEs to provide continuity.</p><p>(shrug) A year later the CIO was convicted for an elaborate price fixing scheme, but received a lenient sentence because the scam relied on that same contractor's code--which was deemed unreadable, making the criminal intent difficult to prove.</p></htmltext>
<tokenext>It 's a mixed bag , i.e. , a blessing and a curse.I once inherited 10,000 lines of C source running under SCO Xenix ( circa 1990 ) with exactly two comments , viz " Watch out , this part 's tricky , " and " Just in case .
" The code featured one- and two-letter variables , heavy variable reuse , and , yes , GOTOs .
The only two parts that were difficult were the custom curses and termio " modules " .Then there was the stuff written for DOS that had uneven numerical/ASCII conversions.Fortunately , my boss understood the problem and gave me time to figure out , fix , and document the source .
It was maddening at times , but at the end of that tunnel , I 'd learned a lot about several topics that I do n't think I could have figured out without having to implement it myself.After fixing the bugs , the next task was to implement a new feature .
I was very glad I 'd taken the time to document everything before adding to the monolith.Then my boss gave me 30 days off to make up for the extra hours I 'd worked without compensation .
He asked that I check voicemail daily and remain available .
Meanwhile , they fired my old boss and neglected to tell me .
On the day I returned , my new boss stopped me before I 'd even reached my desk to tell me that he was my new boss , and that they 'd be taking the unauthorized vacation out of my paychecks .
I stood there , wondering what it was that held me there , and found nothing .
I said , " You know what ?
I quit .
" I turned to leave , and the new guy grabbed me and said , " But you 're the only one who knows how this thing works , now !
" I replied , " Exactly , " and left .
I did not look back .
Armed with my recently acquired expertise , I found a job paying exactly twice the salary I had .
A month later I heard that they had re-enlisted the contractor who 'd written the crappy code .
He charged them $ 1000/day to rewrite my revisions back into his cryptic style in 100 days , then another $ 100K to re-implement the new features I 'd put in.The supreme irony is that I 'd been hired because they did n't want to shell out for his $ 50K bid to add the features they wanted .
My original boss also wanted FTEs to provide continuity .
( shrug ) A year later the CIO was convicted for an elaborate price fixing scheme , but received a lenient sentence because the scam relied on that same contractor 's code--which was deemed unreadable , making the criminal intent difficult to prove .</tokentext>
<sentencetext>It's a mixed bag, i.e., a blessing and a curse.I once inherited 10,000 lines of C source running under SCO Xenix (circa 1990) with exactly two comments, viz "Watch out, this part's tricky," and "Just in case.
" The code featured one- and two-letter variables, heavy variable reuse, and, yes, GOTOs.
The only two parts that were difficult were the custom curses and termio "modules".Then there was the stuff written for DOS that had uneven numerical/ASCII conversions.Fortunately, my boss understood the problem and gave me time to figure out, fix, and document the source.
It was maddening at times, but at the end of that tunnel, I'd learned a lot about several topics that I don't think I could have figured out without having to implement it myself.After fixing the bugs, the next task was to implement a new feature.
I was very glad I'd taken the time to document everything before adding to the monolith.Then my boss gave me 30 days off to make up for the extra hours I'd worked without compensation.
He asked that I check voicemail daily and remain available.
Meanwhile, they fired my old boss and neglected to tell me.
On the day I returned, my new boss stopped me before I'd even reached my desk to tell me that he was my new boss, and that they'd be taking the unauthorized vacation out of my paychecks.
I stood there, wondering what it was that held me there, and found nothing.
I said, "You know what?
I quit.
" I turned to leave, and the new guy grabbed me and said, "But you're the only one who knows how this thing works, now!
"I replied, "Exactly," and left.
I did not look back.
Armed with my recently acquired expertise, I found a job paying exactly twice the salary I had.
A month later I heard that they had re-enlisted the contractor who'd written the crappy code.
He charged them $1000/day to rewrite my revisions back into his cryptic style in 100 days, then another $100K to re-implement the new features I'd put in.The supreme irony is that I'd been hired because they didn't want to shell out for his $50K bid to add the features they wanted.
My original boss also wanted FTEs to provide continuity.
(shrug) A year later the CIO was convicted for an elaborate price fixing scheme, but received a lenient sentence because the scam relied on that same contractor's code--which was deemed unreadable, making the criminal intent difficult to prove.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116694</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30133196</id>
	<title>Re:The comment may also be complex..</title>
	<author>Cederic</author>
	<datestamp>1258489980000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Although if you can highlight a bug in my code, I'll do my best to add a unit test that exposes it.</p><p>Thus passing all the unit tests tends to mean 'no known bugs'.</p><p>Strictly that's not true, as there may be environmental bugs or bugs that are cost ineffective to unit test, but it's a worthy start point.</p><p>I think I've just agreed with you by disagreeing with you. Doh.</p></htmltext>
<tokenext>Although if you can highlight a bug in my code , I 'll do my best to add a unit test that exposes it.Thus passing all the unit tests tends to mean 'no known bugs'.Strictly that 's not true , as there may be environmental bugs or bugs that are cost ineffective to unit test , but it 's a worthy start point.I think I 've just agreed with you by disagreeing with you .
Doh .</tokentext>
<sentencetext>Although if you can highlight a bug in my code, I'll do my best to add a unit test that exposes it.Thus passing all the unit tests tends to mean 'no known bugs'.Strictly that's not true, as there may be environmental bugs or bugs that are cost ineffective to unit test, but it's a worthy start point.I think I've just agreed with you by disagreeing with you.
Doh.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117026</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121178</id>
	<title>Re:Long-winded comments can be very useful</title>
	<author>DHM</author>
	<datestamp>1258364820000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>given a negative attitude towards long comments, many bad programmers will likely simply respond by not commenting their code at all. That's not good.</p></div><p>I agree 100\%, and would add that this can even happen with good programmers. A few years ago I worked at a company whose culture was deeply invested in the XP "comments are a code smell" philosophy. The engineers were all extremely bright, but as a newcomer I found the code to be difficult to work with, in part because there were no comments anywhere. No API docs, no explanations of hacky code (there was plenty of hacky code, by the way), no nothing.<br>The idea was that 1) if code is not clear without comments, it should be rewritten to make it more simple, and 2) if you need help understanding someone's code, just walk over and ask him/her about it. Well, regarding 1), I was trying to maintain/improve some nasty code which had been touched by multiple people over several years and it didn't seem like its lack of comments had led to any kind of refactoring or simplification. And regarding 2), the company now no longer exists, and while the IP now belongs to another company, all of the original engineers have moved on to bigger and better places. I bet the people who had to take over the code would not have minded the additional "smell" of a few well-placed comments.<nobr> <wbr></nobr>:-)</p></div>
	</htmltext>
<tokenext>given a negative attitude towards long comments , many bad programmers will likely simply respond by not commenting their code at all .
That 's not good.I agree 100 \ % , and would add that this can even happen with good programmers .
A few years ago I worked at a company whose culture was deeply invested in the XP " comments are a code smell " philosophy .
The engineers were all extremely bright , but as a newcomer I found the code to be difficult to work with , in part because there were no comments anywhere .
No API docs , no explanations of hacky code ( there was plenty of hacky code , by the way ) , no nothing.The idea was that 1 ) if code is not clear without comments , it should be rewritten to make it more simple , and 2 ) if you need help understanding someone 's code , just walk over and ask him/her about it .
Well , regarding 1 ) , I was trying to maintain/improve some nasty code which had been touched by multiple people over several years and it did n't seem like its lack of comments had led to any kind of refactoring or simplification .
And regarding 2 ) , the company now no longer exists , and while the IP now belongs to another company , all of the original engineers have moved on to bigger and better places .
I bet the people who had to take over the code would not have minded the additional " smell " of a few well-placed comments .
: - )</tokentext>
<sentencetext>given a negative attitude towards long comments, many bad programmers will likely simply respond by not commenting their code at all.
That's not good.I agree 100\%, and would add that this can even happen with good programmers.
A few years ago I worked at a company whose culture was deeply invested in the XP "comments are a code smell" philosophy.
The engineers were all extremely bright, but as a newcomer I found the code to be difficult to work with, in part because there were no comments anywhere.
No API docs, no explanations of hacky code (there was plenty of hacky code, by the way), no nothing.The idea was that 1) if code is not clear without comments, it should be rewritten to make it more simple, and 2) if you need help understanding someone's code, just walk over and ask him/her about it.
Well, regarding 1), I was trying to maintain/improve some nasty code which had been touched by multiple people over several years and it didn't seem like its lack of comments had led to any kind of refactoring or simplification.
And regarding 2), the company now no longer exists, and while the IP now belongs to another company, all of the original engineers have moved on to bigger and better places.
I bet the people who had to take over the code would not have minded the additional "smell" of a few well-placed comments.
:-)
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116672</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30127916</id>
	<title>Re:Arguments for and against</title>
	<author>Zet</author>
	<datestamp>1258466820000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>If people are not keeping the comments in synch with<br>the code, *that* is the maintainability issue.  Bad<br>comments (not concise, not informative, not clear)<br>may be harder to keep up-to-date, but that's not any<br>different from poorly-written code being hard to<br>understand or update.</p><p>Comments should be viewed as an intrinsic part of the<br>code--and if you change the machine-oriented part you<br>better be sure that the human-oriented part is updated<br>to reflect the change.  And if necessary, improve the<br>comments while you're at it.</p></htmltext>
<tokenext>If people are not keeping the comments in synch withthe code , * that * is the maintainability issue .
Badcomments ( not concise , not informative , not clear ) may be harder to keep up-to-date , but that 's not anydifferent from poorly-written code being hard tounderstand or update.Comments should be viewed as an intrinsic part of thecode--and if you change the machine-oriented part youbetter be sure that the human-oriented part is updatedto reflect the change .
And if necessary , improve thecomments while you 're at it .</tokentext>
<sentencetext>If people are not keeping the comments in synch withthe code, *that* is the maintainability issue.
Badcomments (not concise, not informative, not clear)may be harder to keep up-to-date, but that's not anydifferent from poorly-written code being hard tounderstand or update.Comments should be viewed as an intrinsic part of thecode--and if you change the machine-oriented part youbetter be sure that the human-oriented part is updatedto reflect the change.
And if necessary, improve thecomments while you're at it.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116748</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116892</id>
	<title>Re:The comment may also be complex..</title>
	<author>Abcd1234</author>
	<datestamp>1258393860000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>5</modscore>
	<htmltext><p><i>The code worked, but I didn't understand why and said so. Is that bad coding? It worked!</i></p><p>Yes.  It's bad coding.  Very very bad coding.  And, no offense, but it indicates intellectual laziness on your part.</p><p>Any developer worth their salt would spend the time to understand *why* their code is mysteriously working, rather than just throwing up their hands and moving on, as a) it might be working for your test cases but still be incorrect, and b) anyone coming along later will be hosed, as if you couldn't understand it, there's a good chance they won't be able to, either.  And of course, d) any developer worth their salt *wants* to know why their code is working, simply because it's interesting and *part of their job*.</p></htmltext>
<tokenext>The code worked , but I did n't understand why and said so .
Is that bad coding ?
It worked ! Yes .
It 's bad coding .
Very very bad coding .
And , no offense , but it indicates intellectual laziness on your part.Any developer worth their salt would spend the time to understand * why * their code is mysteriously working , rather than just throwing up their hands and moving on , as a ) it might be working for your test cases but still be incorrect , and b ) anyone coming along later will be hosed , as if you could n't understand it , there 's a good chance they wo n't be able to , either .
And of course , d ) any developer worth their salt * wants * to know why their code is working , simply because it 's interesting and * part of their job * .</tokentext>
<sentencetext>The code worked, but I didn't understand why and said so.
Is that bad coding?
It worked!Yes.
It's bad coding.
Very very bad coding.
And, no offense, but it indicates intellectual laziness on your part.Any developer worth their salt would spend the time to understand *why* their code is mysteriously working, rather than just throwing up their hands and moving on, as a) it might be working for your test cases but still be incorrect, and b) anyone coming along later will be hosed, as if you couldn't understand it, there's a good chance they won't be able to, either.
And of course, d) any developer worth their salt *wants* to know why their code is working, simply because it's interesting and *part of their job*.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116652</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117366</id>
	<title>Comments are for future maintainers</title>
	<author>cwills</author>
	<datestamp>1258395780000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>3</modscore>
	<htmltext>The whole purpose of comments is to explain the code so that future maintainers (including the author of the code) can easily understand what is going on.  If done right, a maintainer can pick up a module and come up to speed as to what the code does, why it does it, and any thing else that might trip them up.  Comments need to capture the developers thoughts from when the code was being designed and written.  The reasoning and ideas behind an algorithm that took several months to design cannot be truly captured with a 3 line comment and 25 lines of code.
<p>
I feel that comments can be broken into four types:
</p><ol>
<li>Boiler plate front matter.  These are the comments that are <i>required</i> by the coding standards of the shop.  Usually contains copyright notices, author's name, list of changes, etc.</li>
<li>Specification and reference comments.  A list of the external references, such as the formal specification for the code, a bibliography for the algorithms used, etc.</li>
<li>Block comments.  These should describe the intent of a larger block of code.  The reader should be able to take all the block comments from a program and have a good understanding what the entire program does.  Block comments should describe the what and why.  Block comments should also describe any gotchas, or special conditions that the maintainer needs to be aware of.</li>
<li>Line comments.  Should describe the purpose of a small number of statements.  Line comments should not merely echo the action of the code itself, but describe what is happening and how the particular action relates to the rest of the program.<blockquote><div><p> <tt>i += 4;<nobr> <wbr></nobr>/* Increment i by 4 */ BAD comment<br> <br>i += 4;<nobr> <wbr></nobr>/* Ignore the first 4 fields */ Better</tt></p></div> </blockquote></li> </ol></div>
	</htmltext>
<tokenext>The whole purpose of comments is to explain the code so that future maintainers ( including the author of the code ) can easily understand what is going on .
If done right , a maintainer can pick up a module and come up to speed as to what the code does , why it does it , and any thing else that might trip them up .
Comments need to capture the developers thoughts from when the code was being designed and written .
The reasoning and ideas behind an algorithm that took several months to design can not be truly captured with a 3 line comment and 25 lines of code .
I feel that comments can be broken into four types : Boiler plate front matter .
These are the comments that are required by the coding standards of the shop .
Usually contains copyright notices , author 's name , list of changes , etc .
Specification and reference comments .
A list of the external references , such as the formal specification for the code , a bibliography for the algorithms used , etc .
Block comments .
These should describe the intent of a larger block of code .
The reader should be able to take all the block comments from a program and have a good understanding what the entire program does .
Block comments should describe the what and why .
Block comments should also describe any gotchas , or special conditions that the maintainer needs to be aware of .
Line comments .
Should describe the purpose of a small number of statements .
Line comments should not merely echo the action of the code itself , but describe what is happening and how the particular action relates to the rest of the program .
i + = 4 ; / * Increment i by 4 * / BAD comment i + = 4 ; / * Ignore the first 4 fields * / Better</tokentext>
<sentencetext>The whole purpose of comments is to explain the code so that future maintainers (including the author of the code) can easily understand what is going on.
If done right, a maintainer can pick up a module and come up to speed as to what the code does, why it does it, and any thing else that might trip them up.
Comments need to capture the developers thoughts from when the code was being designed and written.
The reasoning and ideas behind an algorithm that took several months to design cannot be truly captured with a 3 line comment and 25 lines of code.
I feel that comments can be broken into four types:

Boiler plate front matter.
These are the comments that are required by the coding standards of the shop.
Usually contains copyright notices, author's name, list of changes, etc.
Specification and reference comments.
A list of the external references, such as the formal specification for the code, a bibliography for the algorithms used, etc.
Block comments.
These should describe the intent of a larger block of code.
The reader should be able to take all the block comments from a program and have a good understanding what the entire program does.
Block comments should describe the what and why.
Block comments should also describe any gotchas, or special conditions that the maintainer needs to be aware of.
Line comments.
Should describe the purpose of a small number of statements.
Line comments should not merely echo the action of the code itself, but describe what is happening and how the particular action relates to the rest of the program.
i += 4; /* Increment i by 4 */ BAD comment i += 4; /* Ignore the first 4 fields */ Better  
	</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117442</id>
	<title>Re:I'm an expert!</title>
	<author>McNihil</author>
	<datestamp>1258396020000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>People may laugh at this (it is funny don't get me wrong)<nobr> <wbr></nobr>.... however it is not funny when you get this source dumped on your desktop to find a bug in the project and make a delivery later the same day.</p><p>Function names... sed!</p></htmltext>
<tokenext>People may laugh at this ( it is funny do n't get me wrong ) .... however it is not funny when you get this source dumped on your desktop to find a bug in the project and make a delivery later the same day.Function names... sed !</tokentext>
<sentencetext>People may laugh at this (it is funny don't get me wrong) .... however it is not funny when you get this source dumped on your desktop to find a bug in the project and make a delivery later the same day.Function names... sed!</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116778</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116916</id>
	<title>Re:Sounds right</title>
	<author>MrSenile</author>
	<datestamp>1258393980000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Not entirely true.  I've put in comments and sidelines in code when you had to put in code to get around anomalies in compilers, or sadly still, poor design decisions on 3rd party software you don't have time to work around or don't have the authority or decision to work around that you're forced to include as an API or maybe a subset library.</p><p>For example, in an older glib if you had time\_t defined before a char * pointer, you could mess up with the stack on the linker.</p><p>Other platforms have certain library calls and/or function calls that are slightly different and require different methods to attack with various #ifdefs or autoconf changes.  Having a bit of rhetoric to define why you did something the way you did, guarantees that the next person to pick up your code won't spend unnecessary time digesting code that a simple 20 second read followed by an 'oh yea, that's right' would solve.</p><p>In today's world, making things as fast as possible to do 'catch up' could make the difference between 'make' and 'break' in the corporate model.</p></htmltext>
<tokenext>Not entirely true .
I 've put in comments and sidelines in code when you had to put in code to get around anomalies in compilers , or sadly still , poor design decisions on 3rd party software you do n't have time to work around or do n't have the authority or decision to work around that you 're forced to include as an API or maybe a subset library.For example , in an older glib if you had time \ _t defined before a char * pointer , you could mess up with the stack on the linker.Other platforms have certain library calls and/or function calls that are slightly different and require different methods to attack with various # ifdefs or autoconf changes .
Having a bit of rhetoric to define why you did something the way you did , guarantees that the next person to pick up your code wo n't spend unnecessary time digesting code that a simple 20 second read followed by an 'oh yea , that 's right ' would solve.In today 's world , making things as fast as possible to do 'catch up ' could make the difference between 'make ' and 'break ' in the corporate model .</tokentext>
<sentencetext>Not entirely true.
I've put in comments and sidelines in code when you had to put in code to get around anomalies in compilers, or sadly still, poor design decisions on 3rd party software you don't have time to work around or don't have the authority or decision to work around that you're forced to include as an API or maybe a subset library.For example, in an older glib if you had time\_t defined before a char * pointer, you could mess up with the stack on the linker.Other platforms have certain library calls and/or function calls that are slightly different and require different methods to attack with various #ifdefs or autoconf changes.
Having a bit of rhetoric to define why you did something the way you did, guarantees that the next person to pick up your code won't spend unnecessary time digesting code that a simple 20 second read followed by an 'oh yea, that's right' would solve.In today's world, making things as fast as possible to do 'catch up' could make the difference between 'make' and 'break' in the corporate model.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116694</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30128432</id>
	<title>Re:You are not expected to understand this</title>
	<author>Anonymous</author>
	<datestamp>1258471200000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>In this case, the code is commented, and says exactly what it does and why, and the comment is totally useless.<br>Wouldn't it have been a lot more useful to use more time to make descriptive variable/method names that tell what what they do, and just skip the commenting?</p></htmltext>
<tokenext>In this case , the code is commented , and says exactly what it does and why , and the comment is totally useless.Would n't it have been a lot more useful to use more time to make descriptive variable/method names that tell what what they do , and just skip the commenting ?</tokentext>
<sentencetext>In this case, the code is commented, and says exactly what it does and why, and the comment is totally useless.Wouldn't it have been a lot more useful to use more time to make descriptive variable/method names that tell what what they do, and just skip the commenting?</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117090</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118186</id>
	<title>Long comments - simply</title>
	<author>Anonymous</author>
	<datestamp>1258398120000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>The simple thing is a comment should be meaningful. A simple statement or a long explanation it should MEAN something to those who see it. If you write a long comment and it needs to be long fine, but if you write a 500 word essay that boils down to nothing (we all remember the school English assignment about the book we never read...) the get it out of there. No comments make a mess but so do long winded nothings. On that note I'll shut up.</p></htmltext>
<tokenext>The simple thing is a comment should be meaningful .
A simple statement or a long explanation it should MEAN something to those who see it .
If you write a long comment and it needs to be long fine , but if you write a 500 word essay that boils down to nothing ( we all remember the school English assignment about the book we never read... ) the get it out of there .
No comments make a mess but so do long winded nothings .
On that note I 'll shut up .</tokentext>
<sentencetext>The simple thing is a comment should be meaningful.
A simple statement or a long explanation it should MEAN something to those who see it.
If you write a long comment and it needs to be long fine, but if you write a 500 word essay that boils down to nothing (we all remember the school English assignment about the book we never read...) the get it out of there.
No comments make a mess but so do long winded nothings.
On that note I'll shut up.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116666</id>
	<title>Nonesense</title>
	<author>Anonymous</author>
	<datestamp>1258393200000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>1</modscore>
	<htmltext><p>Many people who write code are not native English speakers.  it would be silly to expect their code or comments to read like a Thomas Hardy novel.</p><p>In addition, some of us write comments first and then fill in the code.  Often, in fact quite often, the code evolves past what the comments say.</p><p>Someone who wastes time producing grammer-school perfect comments is wasting time that could be better used by making the code itself better.</p></htmltext>
<tokenext>Many people who write code are not native English speakers .
it would be silly to expect their code or comments to read like a Thomas Hardy novel.In addition , some of us write comments first and then fill in the code .
Often , in fact quite often , the code evolves past what the comments say.Someone who wastes time producing grammer-school perfect comments is wasting time that could be better used by making the code itself better .</tokentext>
<sentencetext>Many people who write code are not native English speakers.
it would be silly to expect their code or comments to read like a Thomas Hardy novel.In addition, some of us write comments first and then fill in the code.
Often, in fact quite often, the code evolves past what the comments say.Someone who wastes time producing grammer-school perfect comments is wasting time that could be better used by making the code itself better.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117134</id>
	<title>Re:The comment may also be complex..</title>
	<author>YXdr</author>
	<datestamp>1258394880000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>5</modscore>
	<htmltext><p><nobr> <wbr></nobr><i>... but if it passes the Unit Tests<nobr> <wbr></nobr>...</i>
</p><p>
That kinda presumes that the unit tests are good, doesn't it?  Which means that somewhere, somehow, somebody has to know what problem they are trying to solve.
</p><p>
Defining 'good enough' is really tough. I've seen perfectionists get bogged down, but even more often, I've seen folks that invoke the 'it's good enough' mantra as a cover for sloppiness and incompetence.
</p></htmltext>
<tokenext>... but if it passes the Unit Tests .. . That kinda presumes that the unit tests are good , does n't it ?
Which means that somewhere , somehow , somebody has to know what problem they are trying to solve .
Defining 'good enough ' is really tough .
I 've seen perfectionists get bogged down , but even more often , I 've seen folks that invoke the 'it 's good enough ' mantra as a cover for sloppiness and incompetence .</tokentext>
<sentencetext> ... but if it passes the Unit Tests ...

That kinda presumes that the unit tests are good, doesn't it?
Which means that somewhere, somehow, somebody has to know what problem they are trying to solve.
Defining 'good enough' is really tough.
I've seen perfectionists get bogged down, but even more often, I've seen folks that invoke the 'it's good enough' mantra as a cover for sloppiness and incompetence.
</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116726</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121264</id>
	<title>Re:I agree, with reservations</title>
	<author>syousef</author>
	<datestamp>1258365180000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><i>From 30 years of developing software, I've found time and time again that it actually does seem that people who don't know or care about the difference between "their" and "they're" are also too sloppy, unintelligent or just not anal enough to write clean, supportable and robust code.</i></p><p>Oh what horse shit. There are plenty of good coders that know to focus their efforts on conveying the meaning in their comments without worrying about. People get anal about the wrong things. For example I've seen SVN and Checkstyle filters that prevent checkin of code if any comment has a first line that does not end in a full stop. That is fucking ridiculous and a misdirection of effort and abuse of the tools as far as I'm concerned.</p><p>I only have 15 or so years in software, but I feel it's enough to make this comment.</p></htmltext>
<tokenext>From 30 years of developing software , I 've found time and time again that it actually does seem that people who do n't know or care about the difference between " their " and " they 're " are also too sloppy , unintelligent or just not anal enough to write clean , supportable and robust code.Oh what horse shit .
There are plenty of good coders that know to focus their efforts on conveying the meaning in their comments without worrying about .
People get anal about the wrong things .
For example I 've seen SVN and Checkstyle filters that prevent checkin of code if any comment has a first line that does not end in a full stop .
That is fucking ridiculous and a misdirection of effort and abuse of the tools as far as I 'm concerned.I only have 15 or so years in software , but I feel it 's enough to make this comment .</tokentext>
<sentencetext>From 30 years of developing software, I've found time and time again that it actually does seem that people who don't know or care about the difference between "their" and "they're" are also too sloppy, unintelligent or just not anal enough to write clean, supportable and robust code.Oh what horse shit.
There are plenty of good coders that know to focus their efforts on conveying the meaning in their comments without worrying about.
People get anal about the wrong things.
For example I've seen SVN and Checkstyle filters that prevent checkin of code if any comment has a first line that does not end in a full stop.
That is fucking ridiculous and a misdirection of effort and abuse of the tools as far as I'm concerned.I only have 15 or so years in software, but I feel it's enough to make this comment.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116868</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30125040</id>
	<title>Re:Non-native English speakers</title>
	<author>Anonymous</author>
	<datestamp>1258384980000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>I have to agree with this one. I've known plenty of people who are absolutely phenomenal programmers and can't spell for s*** (many of them were non-native English speakers). Language competency and attention to detail have no real correlation. I really detest broad sweeping judgements like this... It's just incredibly ignorant. Also, just because someone isn't OCD to that extent doesn't mean that they aren't good programmers; they just don't place as much value on spelling/language errors in comments as they do on the code. As long as the code itself is solid, errors in comment language aren't really that important.<br>(I have a Master's degree in English as well as Computer Science, but I realize when language can take a back-burner to correct code.)</p></htmltext>
<tokenext>I have to agree with this one .
I 've known plenty of people who are absolutely phenomenal programmers and ca n't spell for s * * * ( many of them were non-native English speakers ) .
Language competency and attention to detail have no real correlation .
I really detest broad sweeping judgements like this... It 's just incredibly ignorant .
Also , just because someone is n't OCD to that extent does n't mean that they are n't good programmers ; they just do n't place as much value on spelling/language errors in comments as they do on the code .
As long as the code itself is solid , errors in comment language are n't really that important .
( I have a Master 's degree in English as well as Computer Science , but I realize when language can take a back-burner to correct code .
)</tokentext>
<sentencetext>I have to agree with this one.
I've known plenty of people who are absolutely phenomenal programmers and can't spell for s*** (many of them were non-native English speakers).
Language competency and attention to detail have no real correlation.
I really detest broad sweeping judgements like this... It's just incredibly ignorant.
Also, just because someone isn't OCD to that extent doesn't mean that they aren't good programmers; they just don't place as much value on spelling/language errors in comments as they do on the code.
As long as the code itself is solid, errors in comment language aren't really that important.
(I have a Master's degree in English as well as Computer Science, but I realize when language can take a back-burner to correct code.
)</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116734</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117144</id>
	<title>OT on long comments</title>
	<author>FrankSchwab</author>
	<datestamp>1258394940000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>5</modscore>
	<htmltext>Being as this is devolving into a discussion of long comments, rather than a discussion of whether mispellings in comments indicate a lack of attention to detail in coding, I thought I'd throw in something.
<p>
To maintain some sense of topicality: I don't particularly agree with the blog post.  As someone with good English skills, I've read a lot of code where the English language skills (and thus spelling and grammar in the comments) of the coder are below mine, but their skills in the computer language at issue are superior to mine.  Frankly, there's a far greater relationship between accuracy of the comments (do they actually describe what the code does) and the quality of the code, than there is between spelling, subject-verb agreement, and number of spaces after a period and the quality of the code.  This relationship does follow the blog author's contention about coders needing to be nit-pickers.
</p><p>
Occasionally in my coding, I write a novel in the function header.  Generally, this isn't because I don't understand the problem so much as its because I do understand the problem.  I've spent hours or days understanding the problem, and the particular necessray function that implements the solution, and I don't relish spending hours or days 6 months in the future remembering what I know today.  The interesting thing is that, most of the time, the novel is multiple times larger than the function - 50 lines of comment for a 20 NCLOC function isn't unheard of.
</p><p>
In my specialty (embedded systems, with especially tight hardware integration), there are functions that need to be written that deal with extraordinarily complex situations.  Many times, the bare code tells a misleadingly simple tale - "do this, that, and the other thing", rather than (as Russ Nelson pointed out above) </p><p><div class="quote"><p>but to explain all the other code that could have been written, but wasn't</p></div><p>.  Oftentimes, the novel is there to explain all the ways to trip up in this 20-line function - e.g. unspecified hardware dependencies, subtle system dependencies, unobvious race conditions.  Sometimes its there to explain why, no matter how wrong the function appears, it is actually correct.
</p></div>
	</htmltext>
<tokenext>Being as this is devolving into a discussion of long comments , rather than a discussion of whether mispellings in comments indicate a lack of attention to detail in coding , I thought I 'd throw in something .
To maintain some sense of topicality : I do n't particularly agree with the blog post .
As someone with good English skills , I 've read a lot of code where the English language skills ( and thus spelling and grammar in the comments ) of the coder are below mine , but their skills in the computer language at issue are superior to mine .
Frankly , there 's a far greater relationship between accuracy of the comments ( do they actually describe what the code does ) and the quality of the code , than there is between spelling , subject-verb agreement , and number of spaces after a period and the quality of the code .
This relationship does follow the blog author 's contention about coders needing to be nit-pickers .
Occasionally in my coding , I write a novel in the function header .
Generally , this is n't because I do n't understand the problem so much as its because I do understand the problem .
I 've spent hours or days understanding the problem , and the particular necessray function that implements the solution , and I do n't relish spending hours or days 6 months in the future remembering what I know today .
The interesting thing is that , most of the time , the novel is multiple times larger than the function - 50 lines of comment for a 20 NCLOC function is n't unheard of .
In my specialty ( embedded systems , with especially tight hardware integration ) , there are functions that need to be written that deal with extraordinarily complex situations .
Many times , the bare code tells a misleadingly simple tale - " do this , that , and the other thing " , rather than ( as Russ Nelson pointed out above ) but to explain all the other code that could have been written , but was n't .
Oftentimes , the novel is there to explain all the ways to trip up in this 20-line function - e.g .
unspecified hardware dependencies , subtle system dependencies , unobvious race conditions .
Sometimes its there to explain why , no matter how wrong the function appears , it is actually correct .</tokentext>
<sentencetext>Being as this is devolving into a discussion of long comments, rather than a discussion of whether mispellings in comments indicate a lack of attention to detail in coding, I thought I'd throw in something.
To maintain some sense of topicality: I don't particularly agree with the blog post.
As someone with good English skills, I've read a lot of code where the English language skills (and thus spelling and grammar in the comments) of the coder are below mine, but their skills in the computer language at issue are superior to mine.
Frankly, there's a far greater relationship between accuracy of the comments (do they actually describe what the code does) and the quality of the code, than there is between spelling, subject-verb agreement, and number of spaces after a period and the quality of the code.
This relationship does follow the blog author's contention about coders needing to be nit-pickers.
Occasionally in my coding, I write a novel in the function header.
Generally, this isn't because I don't understand the problem so much as its because I do understand the problem.
I've spent hours or days understanding the problem, and the particular necessray function that implements the solution, and I don't relish spending hours or days 6 months in the future remembering what I know today.
The interesting thing is that, most of the time, the novel is multiple times larger than the function - 50 lines of comment for a 20 NCLOC function isn't unheard of.
In my specialty (embedded systems, with especially tight hardware integration), there are functions that need to be written that deal with extraordinarily complex situations.
Many times, the bare code tells a misleadingly simple tale - "do this, that, and the other thing", rather than (as Russ Nelson pointed out above) but to explain all the other code that could have been written, but wasn't.
Oftentimes, the novel is there to explain all the ways to trip up in this 20-line function - e.g.
unspecified hardware dependencies, subtle system dependencies, unobvious race conditions.
Sometimes its there to explain why, no matter how wrong the function appears, it is actually correct.

	</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121952</id>
	<title>Flogger</title>
	<author>Anonymous</author>
	<datestamp>1258367640000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I once mis-spelled the word "fogger" by typing "flogger."  I hadn't realized it until a co-worker need to port my code to another application.  We left it as flogger simply for amusement.  The code worked properly though.</p></htmltext>
<tokenext>I once mis-spelled the word " fogger " by typing " flogger .
" I had n't realized it until a co-worker need to port my code to another application .
We left it as flogger simply for amusement .
The code worked properly though .</tokentext>
<sentencetext>I once mis-spelled the word "fogger" by typing "flogger.
"  I hadn't realized it until a co-worker need to port my code to another application.
We left it as flogger simply for amusement.
The code worked properly though.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120156</id>
	<title>Re:Seems reasonable</title>
	<author>Anonymous</author>
	<datestamp>1258404120000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>"your" huh?</p></htmltext>
<tokenext>" your " huh ?</tokentext>
<sentencetext>"your" huh?</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116610</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121204</id>
	<title>It's just another indicator of how good you are</title>
	<author>Anonymous</author>
	<datestamp>1258364940000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>The range of views aren't exactly shocking,  somewhat upsetting at times though.</p><p>Comments should explain the intent in clear language,  in my career I can't count how many times that helped someone else fix a bug in a domain that they knew very little about.     Yes,  the code does what the code does and comments may not be consistent with that but they should and those inconsistencies are defects.  Really good code doesn't need a lot of comments but what about the domain knowledge?  Is there any chance you'll bring someone new to the team that doesn't know the domain yet and want them to work on bugs?  Is there any chance that the domain might shift?</p><p>As to the correctness and the effort put in to comments,  it's just another indicator,  is the author of the code a hack or a craftsman?     Shit,  modern IDEs even have spell checkers builtin for comments,  it's not that hard.   I've struggled with it at parts of my career,  we have this pressure to work fast to get things done quickly and especially in American start-ups we want to skip the bullshit and get to work on the real problems we're trying to solve.   It's this hacker culture thing that has been created,  you hear legends about guys that coded all night and how they wrote xyz in a month of 7 day work weeks and so we think that the LoC count is what matters.  As a result, I've seen giant complicated programs with minimal comments,  I've seen labs with just complete messes of wiring, tons of other things ignored,  install and upgrade processes completely ignored because "that's not coding"... all these roadblocks that are created that eventually prevent a team from being really agile and quick.   Basically,  if you do a half-assed job at some things, you'll probably do a  half-assed job at others and it's just a matter of time before that affects the product.  As a software engineer, doing a half-assed job at things that touch the code is terrible,  at that includes comments.   It's better to have good comments and not need them than it is to not have them and need them.      It's funny, everyone who has written code has spent time fixing some small one line defect, you know an off by one or something like that,  and it's stupid and easy once you see it but that didn't prevent it from being written in the first place.    You cna't be a perfectionist and do everything perfect but what things do you want to half ass and who do you want it to affect?</p><p>It reminds me of another saying someone told me a long while back.   Cars don't have brakes so they can go slowly,  they have brakes so they can go fast.   It strikes me that if you don't have time to write a few lines about what some method or class or function intends to accomplish in plain English,  you've got some other problems.   You need to pump the brakes a little.   You can code as fast as you want and cut out keystrokes and, clearly a bracket is much less time consuming that "BEGIN"  but at the end of it all, can you speed up the thought process of architecting good software?    I'll do them one better,  coders that don't comment usually aren't architects and usually aren't nearly as senior as they like to think they are.   I don't think it's universal but I've seen at least a couple cases where they were difficult people to have on teams, they simply didn't like to work with others and probably spent more time defending their turf or jobs than building killer products.  Sure they can code,  but I usually want something else on my team,  there are a whole lot of guys in China and India that can code...</p></htmltext>
<tokenext>The range of views are n't exactly shocking , somewhat upsetting at times though.Comments should explain the intent in clear language , in my career I ca n't count how many times that helped someone else fix a bug in a domain that they knew very little about .
Yes , the code does what the code does and comments may not be consistent with that but they should and those inconsistencies are defects .
Really good code does n't need a lot of comments but what about the domain knowledge ?
Is there any chance you 'll bring someone new to the team that does n't know the domain yet and want them to work on bugs ?
Is there any chance that the domain might shift ? As to the correctness and the effort put in to comments , it 's just another indicator , is the author of the code a hack or a craftsman ?
Shit , modern IDEs even have spell checkers builtin for comments , it 's not that hard .
I 've struggled with it at parts of my career , we have this pressure to work fast to get things done quickly and especially in American start-ups we want to skip the bullshit and get to work on the real problems we 're trying to solve .
It 's this hacker culture thing that has been created , you hear legends about guys that coded all night and how they wrote xyz in a month of 7 day work weeks and so we think that the LoC count is what matters .
As a result , I 've seen giant complicated programs with minimal comments , I 've seen labs with just complete messes of wiring , tons of other things ignored , install and upgrade processes completely ignored because " that 's not coding " ... all these roadblocks that are created that eventually prevent a team from being really agile and quick .
Basically , if you do a half-assed job at some things , you 'll probably do a half-assed job at others and it 's just a matter of time before that affects the product .
As a software engineer , doing a half-assed job at things that touch the code is terrible , at that includes comments .
It 's better to have good comments and not need them than it is to not have them and need them .
It 's funny , everyone who has written code has spent time fixing some small one line defect , you know an off by one or something like that , and it 's stupid and easy once you see it but that did n't prevent it from being written in the first place .
You cna't be a perfectionist and do everything perfect but what things do you want to half ass and who do you want it to affect ? It reminds me of another saying someone told me a long while back .
Cars do n't have brakes so they can go slowly , they have brakes so they can go fast .
It strikes me that if you do n't have time to write a few lines about what some method or class or function intends to accomplish in plain English , you 've got some other problems .
You need to pump the brakes a little .
You can code as fast as you want and cut out keystrokes and , clearly a bracket is much less time consuming that " BEGIN " but at the end of it all , can you speed up the thought process of architecting good software ?
I 'll do them one better , coders that do n't comment usually are n't architects and usually are n't nearly as senior as they like to think they are .
I do n't think it 's universal but I 've seen at least a couple cases where they were difficult people to have on teams , they simply did n't like to work with others and probably spent more time defending their turf or jobs than building killer products .
Sure they can code , but I usually want something else on my team , there are a whole lot of guys in China and India that can code.. .</tokentext>
<sentencetext>The range of views aren't exactly shocking,  somewhat upsetting at times though.Comments should explain the intent in clear language,  in my career I can't count how many times that helped someone else fix a bug in a domain that they knew very little about.
Yes,  the code does what the code does and comments may not be consistent with that but they should and those inconsistencies are defects.
Really good code doesn't need a lot of comments but what about the domain knowledge?
Is there any chance you'll bring someone new to the team that doesn't know the domain yet and want them to work on bugs?
Is there any chance that the domain might shift?As to the correctness and the effort put in to comments,  it's just another indicator,  is the author of the code a hack or a craftsman?
Shit,  modern IDEs even have spell checkers builtin for comments,  it's not that hard.
I've struggled with it at parts of my career,  we have this pressure to work fast to get things done quickly and especially in American start-ups we want to skip the bullshit and get to work on the real problems we're trying to solve.
It's this hacker culture thing that has been created,  you hear legends about guys that coded all night and how they wrote xyz in a month of 7 day work weeks and so we think that the LoC count is what matters.
As a result, I've seen giant complicated programs with minimal comments,  I've seen labs with just complete messes of wiring, tons of other things ignored,  install and upgrade processes completely ignored because "that's not coding"... all these roadblocks that are created that eventually prevent a team from being really agile and quick.
Basically,  if you do a half-assed job at some things, you'll probably do a  half-assed job at others and it's just a matter of time before that affects the product.
As a software engineer, doing a half-assed job at things that touch the code is terrible,  at that includes comments.
It's better to have good comments and not need them than it is to not have them and need them.
It's funny, everyone who has written code has spent time fixing some small one line defect, you know an off by one or something like that,  and it's stupid and easy once you see it but that didn't prevent it from being written in the first place.
You cna't be a perfectionist and do everything perfect but what things do you want to half ass and who do you want it to affect?It reminds me of another saying someone told me a long while back.
Cars don't have brakes so they can go slowly,  they have brakes so they can go fast.
It strikes me that if you don't have time to write a few lines about what some method or class or function intends to accomplish in plain English,  you've got some other problems.
You need to pump the brakes a little.
You can code as fast as you want and cut out keystrokes and, clearly a bracket is much less time consuming that "BEGIN"  but at the end of it all, can you speed up the thought process of architecting good software?
I'll do them one better,  coders that don't comment usually aren't architects and usually aren't nearly as senior as they like to think they are.
I don't think it's universal but I've seen at least a couple cases where they were difficult people to have on teams, they simply didn't like to work with others and probably spent more time defending their turf or jobs than building killer products.
Sure they can code,  but I usually want something else on my team,  there are a whole lot of guys in China and India that can code...</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30202712</id>
	<title>Re:I don't understand?</title>
	<author>Anonymous</author>
	<datestamp>1258995480000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><blockquote><div><p>Weather the code is ugly or not has nothing to do with the code working, the code works or doesn't. Past that the code is only rated based on memory and CPU use, thats it, not comments, not identing or anything else.</p></div></blockquote><p>
Code serves two purposes: 1) to build an algorithmic software "machine" that solves a problem, and 2) to document that machine for programmers who need to modify or fix it.
</p><p>
You're right that "ugly" code with missing or poor comments doesn't affect purpose #1; unfortunately, it fails utterly at purpose #2. Does that help?</p></div>
	</htmltext>
<tokenext>Weather the code is ugly or not has nothing to do with the code working , the code works or does n't .
Past that the code is only rated based on memory and CPU use , thats it , not comments , not identing or anything else .
Code serves two purposes : 1 ) to build an algorithmic software " machine " that solves a problem , and 2 ) to document that machine for programmers who need to modify or fix it .
You 're right that " ugly " code with missing or poor comments does n't affect purpose # 1 ; unfortunately , it fails utterly at purpose # 2 .
Does that help ?</tokentext>
<sentencetext>Weather the code is ugly or not has nothing to do with the code working, the code works or doesn't.
Past that the code is only rated based on memory and CPU use, thats it, not comments, not identing or anything else.
Code serves two purposes: 1) to build an algorithmic software "machine" that solves a problem, and 2) to document that machine for programmers who need to modify or fix it.
You're right that "ugly" code with missing or poor comments doesn't affect purpose #1; unfortunately, it fails utterly at purpose #2.
Does that help?
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118918</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30123574</id>
	<title>I can't believe the OP is even possible</title>
	<author>syntap</author>
	<datestamp>1258374420000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>2</modscore>
	<htmltext><p>Whoever is criticizing grammar in comments obviously never had to look through legacy code and ask him/herself "WTF was this developer thinking?!"  Or better yet, looking at one's own code written five years earlier and asked him/herself "WTF was I thinking?!"  In those cases, any comments at all will provide clues.</p><p>We should be encouraging coders to use comments \_at all\_, not giving incentive to shortchange it because they are going to be graded on stuff the compiler ignores.  Any coder stuck with making changes to old code will be very thankful to see long-winded comments.</p><p>Let's not forget that code is read many more times than it is written.  Yes, it would be nice to have precise comments that tell all.  But if a coder wants to go into detail then friggin let him, to suggest otherwise is just dumb.</p></htmltext>
<tokenext>Whoever is criticizing grammar in comments obviously never had to look through legacy code and ask him/herself " WTF was this developer thinking ? !
" Or better yet , looking at one 's own code written five years earlier and asked him/herself " WTF was I thinking ? !
" In those cases , any comments at all will provide clues.We should be encouraging coders to use comments \ _at all \ _ , not giving incentive to shortchange it because they are going to be graded on stuff the compiler ignores .
Any coder stuck with making changes to old code will be very thankful to see long-winded comments.Let 's not forget that code is read many more times than it is written .
Yes , it would be nice to have precise comments that tell all .
But if a coder wants to go into detail then friggin let him , to suggest otherwise is just dumb .</tokentext>
<sentencetext>Whoever is criticizing grammar in comments obviously never had to look through legacy code and ask him/herself "WTF was this developer thinking?!
"  Or better yet, looking at one's own code written five years earlier and asked him/herself "WTF was I thinking?!
"  In those cases, any comments at all will provide clues.We should be encouraging coders to use comments \_at all\_, not giving incentive to shortchange it because they are going to be graded on stuff the compiler ignores.
Any coder stuck with making changes to old code will be very thankful to see long-winded comments.Let's not forget that code is read many more times than it is written.
Yes, it would be nice to have precise comments that tell all.
But if a coder wants to go into detail then friggin let him, to suggest otherwise is just dumb.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30133570</id>
	<title>Re:I write mine in swahili</title>
	<author>Cederic</author>
	<datestamp>1258491420000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Code should always be in English. Comments should always be in the language of the development team.</p><p>I just hope your colleagues are all from Africa<nobr> <wbr></nobr>;)</p></htmltext>
<tokenext>Code should always be in English .
Comments should always be in the language of the development team.I just hope your colleagues are all from Africa ; )</tokentext>
<sentencetext>Code should always be in English.
Comments should always be in the language of the development team.I just hope your colleagues are all from Africa ;)</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30119428</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30136166</id>
	<title>Sometime the "excuse" comment is actually OK.</title>
	<author>Anonymous</author>
	<datestamp>1258457220000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Except of course if you are coding in an MS environment where the work often IS the work-around. Try writing some code to replace template items in a word document using search-and-replace and you'll find yourself writing a long comment about why all the cases are required to deal with the anomalies of what is considered a "word".</p></htmltext>
<tokenext>Except of course if you are coding in an MS environment where the work often IS the work-around .
Try writing some code to replace template items in a word document using search-and-replace and you 'll find yourself writing a long comment about why all the cases are required to deal with the anomalies of what is considered a " word " .</tokentext>
<sentencetext>Except of course if you are coding in an MS environment where the work often IS the work-around.
Try writing some code to replace template items in a word document using search-and-replace and you'll find yourself writing a long comment about why all the cases are required to deal with the anomalies of what is considered a "word".</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117300</id>
	<title>Thats a big relief</title>
	<author>Bai jie</author>
	<datestamp>1258395480000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>I don't comment on my code, so I guess that if the comments are non-existent then the errors are non-existent too!</htmltext>
<tokenext>I do n't comment on my code , so I guess that if the comments are non-existent then the errors are non-existent too !</tokentext>
<sentencetext>I don't comment on my code, so I guess that if the comments are non-existent then the errors are non-existent too!</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116778</id>
	<title>I'm an expert!</title>
	<author>Anonymous</author>
	<datestamp>1258393500000</datestamp>
	<modclass>Funny</modclass>
	<modscore>5</modscore>
	<htmltext><i>"Long-winded 'explanations' of the code in the application's comments (that is, the ones that read like excuses), indicate that the developer probably didn't understand what he was doing.'"</i>
<br> <br>
That's right, I'm an expert and I keep my code comments short and sweet. Observe:
<br> <br><nobr> <wbr></nobr>// This function kicks ass.
<br> <br>
function kick\_ass()<br>
{<br><nobr> <wbr></nobr>...
<br> <br><nobr> <wbr></nobr>// This following code is like Chuck Norris. It doesn't know how to fail.
<br> <br>
while(true)<br>
{<br><nobr> <wbr></nobr>...</htmltext>
<tokenext>" Long-winded 'explanations ' of the code in the application 's comments ( that is , the ones that read like excuses ) , indicate that the developer probably did n't understand what he was doing .
' " That 's right , I 'm an expert and I keep my code comments short and sweet .
Observe : // This function kicks ass .
function kick \ _ass ( ) { .. . // This following code is like Chuck Norris .
It does n't know how to fail .
while ( true ) { .. .</tokentext>
<sentencetext>"Long-winded 'explanations' of the code in the application's comments (that is, the ones that read like excuses), indicate that the developer probably didn't understand what he was doing.
'"
 
That's right, I'm an expert and I keep my code comments short and sweet.
Observe:
  // This function kicks ass.
function kick\_ass()
{ ...
  // This following code is like Chuck Norris.
It doesn't know how to fail.
while(true)
{ ...</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30128336</id>
	<title>For what it is worth</title>
	<author>iaamoac</author>
	<datestamp>1258470600000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>For what it is worth (especially this late in the game) the quality and type of comments added to the code is a combination of several factors.</p><p>1.  Number of expected eyes.  The more people that I expect to see it, the better the comments need to be.<br>2.  Length of development time.  The longer the code takes to write, the better the comments need to be.  For some of my personal/hobby projects that have lasted for months or years, I was lucky to find 20 minutes a day to work on it.  Adding comments to the code was absolutely necessary so that I could get stuff done.<br>3.  Code complexity.  The trickier the code, or the more modules/files that impact the code, the better the comments have to be.<br>4.  Prep-work time.  The longer it took me to figure out what I needed to do (and why), the better the comments need to be.</p><p>Re-reading through this, the longer I expect the code to be around, the better I expect it to be written and commented.  I don't want to waste time trying figure out both the intent AND what the code is actually doing.  Nor do I want others go through that as well.  The better the comments in the code, the faster someone else can get up to speed on the code I have written, which means that it costs the company I work for less $$$ down the road.</p><p>When writing comments, I try to include<nobr> <wbr></nobr>...the 'why' where applicable, and what it is supposed to do, and on the complex code I state<br>
&nbsp; &nbsp; &nbsp; 1.  The INTENT.<br>
&nbsp; &nbsp; &nbsp; 2.  The 'WHY' where applicable.<br>
&nbsp; &nbsp; &nbsp; 3.  Expected state information at various locations for more complex code.</p><p>Readability is a must.  If it is not readable, then from my position it is flat out wrong.  If it is not readable, you (or someone else) can not know if it is right.</p></htmltext>
<tokenext>For what it is worth ( especially this late in the game ) the quality and type of comments added to the code is a combination of several factors.1 .
Number of expected eyes .
The more people that I expect to see it , the better the comments need to be.2 .
Length of development time .
The longer the code takes to write , the better the comments need to be .
For some of my personal/hobby projects that have lasted for months or years , I was lucky to find 20 minutes a day to work on it .
Adding comments to the code was absolutely necessary so that I could get stuff done.3 .
Code complexity .
The trickier the code , or the more modules/files that impact the code , the better the comments have to be.4 .
Prep-work time .
The longer it took me to figure out what I needed to do ( and why ) , the better the comments need to be.Re-reading through this , the longer I expect the code to be around , the better I expect it to be written and commented .
I do n't want to waste time trying figure out both the intent AND what the code is actually doing .
Nor do I want others go through that as well .
The better the comments in the code , the faster someone else can get up to speed on the code I have written , which means that it costs the company I work for less $ $ $ down the road.When writing comments , I try to include ...the 'why ' where applicable , and what it is supposed to do , and on the complex code I state       1 .
The INTENT .
      2 .
The 'WHY ' where applicable .
      3 .
Expected state information at various locations for more complex code.Readability is a must .
If it is not readable , then from my position it is flat out wrong .
If it is not readable , you ( or someone else ) can not know if it is right .</tokentext>
<sentencetext>For what it is worth (especially this late in the game) the quality and type of comments added to the code is a combination of several factors.1.
Number of expected eyes.
The more people that I expect to see it, the better the comments need to be.2.
Length of development time.
The longer the code takes to write, the better the comments need to be.
For some of my personal/hobby projects that have lasted for months or years, I was lucky to find 20 minutes a day to work on it.
Adding comments to the code was absolutely necessary so that I could get stuff done.3.
Code complexity.
The trickier the code, or the more modules/files that impact the code, the better the comments have to be.4.
Prep-work time.
The longer it took me to figure out what I needed to do (and why), the better the comments need to be.Re-reading through this, the longer I expect the code to be around, the better I expect it to be written and commented.
I don't want to waste time trying figure out both the intent AND what the code is actually doing.
Nor do I want others go through that as well.
The better the comments in the code, the faster someone else can get up to speed on the code I have written, which means that it costs the company I work for less $$$ down the road.When writing comments, I try to include ...the 'why' where applicable, and what it is supposed to do, and on the complex code I state
      1.
The INTENT.
      2.
The 'WHY' where applicable.
      3.
Expected state information at various locations for more complex code.Readability is a must.
If it is not readable, then from my position it is flat out wrong.
If it is not readable, you (or someone else) can not know if it is right.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116840</id>
	<title>Too wordy</title>
	<author>Anonymous</author>
	<datestamp>1258393740000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>That was a long-winded blog post, which indicates he probably doesn't know what he's talking about.</p></htmltext>
<tokenext>That was a long-winded blog post , which indicates he probably does n't know what he 's talking about .</tokentext>
<sentencetext>That was a long-winded blog post, which indicates he probably doesn't know what he's talking about.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30122932</id>
	<title>Re:You are not expected to understand this</title>
	<author>Anonymous</author>
	<datestamp>1258371420000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>The real WTF is that he doesn't expect the people reading the code to understand it. ken is teh sucks.</p></htmltext>
<tokenext>The real WTF is that he does n't expect the people reading the code to understand it .
ken is teh sucks .</tokentext>
<sentencetext>The real WTF is that he doesn't expect the people reading the code to understand it.
ken is teh sucks.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117090</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117324</id>
	<title>Author is a Drama Queen</title>
	<author>Tablizer</author>
	<datestamp>1258395600000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>2</modscore>
	<htmltext><p>Everybody has their little "pet signposts" that they use to make wider conclusions. Although there may be small truths to some of them, relying on weak correlations is generally a dangerous way to make conclusions. <b>Good programming involves a wide variety of skills</b>. To focus on a few narrow factors does a disservice to this fact.</p><p>For example, I sometimes put in long comments because the <b>business rules themselves are convoluted</b>. Programming logic cannot make a silk purse out of a sow's ear. Ugly biz rules are ugly biz rules and are not explainable in just a few lines. It's outside of the scope of my duties to clean up the business practices (other than pointing them out sometimes).</p><p>I agree that long comments can serve as a yellow alert to stop and think. But that does not mean that all long comments are inherently a sign of flawed code. The <b>author is being a drama queen</b> via exaggeration. And perhaps it's part piety: I am a careful comment-speller, so you should be also.<br>
&nbsp; &nbsp; &nbsp;</p></htmltext>
<tokenext>Everybody has their little " pet signposts " that they use to make wider conclusions .
Although there may be small truths to some of them , relying on weak correlations is generally a dangerous way to make conclusions .
Good programming involves a wide variety of skills .
To focus on a few narrow factors does a disservice to this fact.For example , I sometimes put in long comments because the business rules themselves are convoluted .
Programming logic can not make a silk purse out of a sow 's ear .
Ugly biz rules are ugly biz rules and are not explainable in just a few lines .
It 's outside of the scope of my duties to clean up the business practices ( other than pointing them out sometimes ) .I agree that long comments can serve as a yellow alert to stop and think .
But that does not mean that all long comments are inherently a sign of flawed code .
The author is being a drama queen via exaggeration .
And perhaps it 's part piety : I am a careful comment-speller , so you should be also .
     </tokentext>
<sentencetext>Everybody has their little "pet signposts" that they use to make wider conclusions.
Although there may be small truths to some of them, relying on weak correlations is generally a dangerous way to make conclusions.
Good programming involves a wide variety of skills.
To focus on a few narrow factors does a disservice to this fact.For example, I sometimes put in long comments because the business rules themselves are convoluted.
Programming logic cannot make a silk purse out of a sow's ear.
Ugly biz rules are ugly biz rules and are not explainable in just a few lines.
It's outside of the scope of my duties to clean up the business practices (other than pointing them out sometimes).I agree that long comments can serve as a yellow alert to stop and think.
But that does not mean that all long comments are inherently a sign of flawed code.
The author is being a drama queen via exaggeration.
And perhaps it's part piety: I am a careful comment-speller, so you should be also.
     </sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30126244</id>
	<title>Re:I agree, with reservations</title>
	<author>Volguus Zildrohar</author>
	<datestamp>1258398300000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>the last thing I'm worried about is making sure I don't confuse "they're" with "their" or with "there"</p></div><p>What's with "making sure"?  It's not exactly hard.</p><p><strong> <em>They're playing with their balls over there.</em> </strong></p><p>Holy shit, how did I <strong>do</strong> that so quickly?</p><p>Bah.</p></div>
	</htmltext>
<tokenext>the last thing I 'm worried about is making sure I do n't confuse " they 're " with " their " or with " there " What 's with " making sure " ?
It 's not exactly hard .
They 're playing with their balls over there .
Holy shit , how did I do that so quickly ? Bah .</tokentext>
<sentencetext>the last thing I'm worried about is making sure I don't confuse "they're" with "their" or with "there"What's with "making sure"?
It's not exactly hard.
They're playing with their balls over there.
Holy shit, how did I do that so quickly?Bah.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117648</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30133548</id>
	<title>Re:Existence of Comments</title>
	<author>tieTYT</author>
	<datestamp>1258491300000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Why was this marked funny?  I actually agree with this.  Obviously, you need comments once in a while, but, they should be rare and the code should document itself most of the time.  The people talking about how helpful comments are probably haven't read Refactoring or Clean Code.</p></htmltext>
<tokenext>Why was this marked funny ?
I actually agree with this .
Obviously , you need comments once in a while , but , they should be rare and the code should document itself most of the time .
The people talking about how helpful comments are probably have n't read Refactoring or Clean Code .</tokentext>
<sentencetext>Why was this marked funny?
I actually agree with this.
Obviously, you need comments once in a while, but, they should be rare and the code should document itself most of the time.
The people talking about how helpful comments are probably haven't read Refactoring or Clean Code.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116872</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117428</id>
	<title>Good code should coment itself.</title>
	<author>Anonymous</author>
	<datestamp>1258395960000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Good code should comment itself and when that is not possible clear and concise code comments should be entered.  If the comments are difficult to read then it follows that the code is probably worse.</p><p>Its not hard for me to believe that someone who didn't take the time to explain themselves clearly probably didn't take the time to think the code through clearly either.</p></htmltext>
<tokenext>Good code should comment itself and when that is not possible clear and concise code comments should be entered .
If the comments are difficult to read then it follows that the code is probably worse.Its not hard for me to believe that someone who did n't take the time to explain themselves clearly probably did n't take the time to think the code through clearly either .</tokentext>
<sentencetext>Good code should comment itself and when that is not possible clear and concise code comments should be entered.
If the comments are difficult to read then it follows that the code is probably worse.Its not hard for me to believe that someone who didn't take the time to explain themselves clearly probably didn't take the time to think the code through clearly either.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30119448</id>
	<title>/* You are not expected to understand this */</title>
	<author>lbalbalba</author>
	<datestamp>1258401960000</datestamp>
	<modclass>Redundant</modclass>
	<modscore>0</modscore>
	<htmltext><a href="http://www.google.com/codesearch/p?hl=nl&amp;sa=N&amp;cd=1&amp;ct=rc#hPV1ny7nbsI/usr/sys/ken/slp.c&amp;q=you\%20are\%20not\%20expected\%20to\%20understand\%20this\%20slp.c&amp;l=325" title="google.com">In the comments of the Sixth Edition Unix operating system.</a> [google.com]</htmltext>
<tokenext>In the comments of the Sixth Edition Unix operating system .
[ google.com ]</tokentext>
<sentencetext>In the comments of the Sixth Edition Unix operating system.
[google.com]</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120810</id>
	<title>I thought code was syntax</title>
	<author>Anonymous</author>
	<datestamp>1258363380000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext>Syntax is like English grammar. The vocab of a computer language is much smaller than that of English.
<br>
<br>
That you need comments to read syntax is like saying you need comments to explain the english in a book--which are typically footnotes and sparsely used. And that's the way it should be--write comments only if the code is unexplainable.
<br>
<br>
The only time I see lots of footnotes in a book/article are in scientific papers--which are typically explaining someone's crazy <i>spin</i> on how the world works.</htmltext>
<tokenext>Syntax is like English grammar .
The vocab of a computer language is much smaller than that of English .
That you need comments to read syntax is like saying you need comments to explain the english in a book--which are typically footnotes and sparsely used .
And that 's the way it should be--write comments only if the code is unexplainable .
The only time I see lots of footnotes in a book/article are in scientific papers--which are typically explaining someone 's crazy spin on how the world works .</tokentext>
<sentencetext>Syntax is like English grammar.
The vocab of a computer language is much smaller than that of English.
That you need comments to read syntax is like saying you need comments to explain the english in a book--which are typically footnotes and sparsely used.
And that's the way it should be--write comments only if the code is unexplainable.
The only time I see lots of footnotes in a book/article are in scientific papers--which are typically explaining someone's crazy spin on how the world works.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116806</id>
	<title>comments and complexity</title>
	<author>bigogre</author>
	<datestamp>1258393620000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Two comments:</p><p>1. Comments are there to tell WHY the code is doing what it is doing, not necessarily what the code is doing.  I deal with code all the time that has comments that tell me what I can easily learn by reading the code, but they don't tell me why so when it is broken I don't know if it is because there is a subtle problem with the code or that the developer didn't know what they were doing.</p><p>2. After literally getting headaches from reading code written by other people I came up with a simple metric:  The complexity of the coding solution to a problem is inversely proportional to how well the developer understood the problem they were trying to solve.  In other words, someone who understands the problem will have a simpler solution than someone who doesn't understand the problem as well.  You can apply this metric to things other than code, too, but it is usually very apparent with software.</p></htmltext>
<tokenext>Two comments : 1 .
Comments are there to tell WHY the code is doing what it is doing , not necessarily what the code is doing .
I deal with code all the time that has comments that tell me what I can easily learn by reading the code , but they do n't tell me why so when it is broken I do n't know if it is because there is a subtle problem with the code or that the developer did n't know what they were doing.2 .
After literally getting headaches from reading code written by other people I came up with a simple metric : The complexity of the coding solution to a problem is inversely proportional to how well the developer understood the problem they were trying to solve .
In other words , someone who understands the problem will have a simpler solution than someone who does n't understand the problem as well .
You can apply this metric to things other than code , too , but it is usually very apparent with software .</tokentext>
<sentencetext>Two comments:1.
Comments are there to tell WHY the code is doing what it is doing, not necessarily what the code is doing.
I deal with code all the time that has comments that tell me what I can easily learn by reading the code, but they don't tell me why so when it is broken I don't know if it is because there is a subtle problem with the code or that the developer didn't know what they were doing.2.
After literally getting headaches from reading code written by other people I came up with a simple metric:  The complexity of the coding solution to a problem is inversely proportional to how well the developer understood the problem they were trying to solve.
In other words, someone who understands the problem will have a simpler solution than someone who doesn't understand the problem as well.
You can apply this metric to things other than code, too, but it is usually very apparent with software.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120924</id>
	<title>Re:Seems reasonable</title>
	<author>Anonymous</author>
	<datestamp>1258363800000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p><div class="quote"><p>[...] willing to spend time on the comments <i>your</i> most likely going to spend [...]</p></div><p>Ouch.<br>you're.</p></div>
	</htmltext>
<tokenext>[ ... ] willing to spend time on the comments your most likely going to spend [ ... ] Ouch.you 're .</tokentext>
<sentencetext>[...] willing to spend time on the comments your most likely going to spend [...]Ouch.you're.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116610</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117572</id>
	<title>Re:Existence of Comments</title>
	<author>Anonymous</author>
	<datestamp>1258396260000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p><div class="quote"><p>If comments even exist, then the code is ugly.  Code should document itself.</p><p>(Any good Perl programmer knows this.)</p></div><p>Ever code in APL?</p></div>
	</htmltext>
<tokenext>If comments even exist , then the code is ugly .
Code should document itself .
( Any good Perl programmer knows this .
) Ever code in APL ?</tokentext>
<sentencetext>If comments even exist, then the code is ugly.
Code should document itself.
(Any good Perl programmer knows this.
)Ever code in APL?
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116872</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116610</id>
	<title>Seems reasonable</title>
	<author>jgtg32a</author>
	<datestamp>1258393020000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>5</modscore>
	<htmltext>Comments do require a bit of effort and time commitment.  If you are willing to spend time on the comments your most likely going to spend more time working the code itself.</htmltext>
<tokenext>Comments do require a bit of effort and time commitment .
If you are willing to spend time on the comments your most likely going to spend more time working the code itself .</tokentext>
<sentencetext>Comments do require a bit of effort and time commitment.
If you are willing to spend time on the comments your most likely going to spend more time working the code itself.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30133288</id>
	<title>Re:Yes, that's bad coding</title>
	<author>Cederic</author>
	<datestamp>1258490340000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I've written unit tests that test all known valid inputs before.</p><p>I'm now trying to remember why that was the appropriate level to which to test, and why we just didn't turn the test cases into a simple map...</p></htmltext>
<tokenext>I 've written unit tests that test all known valid inputs before.I 'm now trying to remember why that was the appropriate level to which to test , and why we just did n't turn the test cases into a simple map.. .</tokentext>
<sentencetext>I've written unit tests that test all known valid inputs before.I'm now trying to remember why that was the appropriate level to which to test, and why we just didn't turn the test cases into a simple map...</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116852</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121246</id>
	<title>Re:I agree, with reservations</title>
	<author>Anonymous</author>
	<datestamp>1258365120000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext>Don't blame it om them! "they're" will get you compilation errors if you use it as a variable<nobr> <wbr></nobr>:)</htmltext>
<tokenext>Do n't blame it om them !
" they 're " will get you compilation errors if you use it as a variable : )</tokentext>
<sentencetext>Don't blame it om them!
"they're" will get you compilation errors if you use it as a variable :)</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116868</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30124816</id>
	<title>Re:Non-native English speakers</title>
	<author>Anonymous</author>
	<datestamp>1258383060000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>I like to throw in some latin phrases for fun.</p><p>I also use foreign language unicode characters for test values when i can.</p></htmltext>
<tokenext>I like to throw in some latin phrases for fun.I also use foreign language unicode characters for test values when i can .</tokentext>
<sentencetext>I like to throw in some latin phrases for fun.I also use foreign language unicode characters for test values when i can.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116734</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116726</id>
	<title>Re:The comment may also be complex..</title>
	<author>Anonymous</author>
	<datestamp>1258393380000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>2</modscore>
	<htmltext>The thing that I find a lot of developers don't understand is the difference between "Good" and "Good Enough"... <br> <br>
In your example, the code you got working for -x, +y may not have been "Good", but if it passes the Unit Tests, then how is it really bad?  Could it be optimized?  Sure...<br> <br>

Those that seek perfection are destined to a life of search.  Those that seek 'working' are destined to a life of success...</htmltext>
<tokenext>The thing that I find a lot of developers do n't understand is the difference between " Good " and " Good Enough " .. . In your example , the code you got working for -x , + y may not have been " Good " , but if it passes the Unit Tests , then how is it really bad ?
Could it be optimized ?
Sure.. . Those that seek perfection are destined to a life of search .
Those that seek 'working ' are destined to a life of success.. .</tokentext>
<sentencetext>The thing that I find a lot of developers don't understand is the difference between "Good" and "Good Enough"...  
In your example, the code you got working for -x, +y may not have been "Good", but if it passes the Unit Tests, then how is it really bad?
Could it be optimized?
Sure... 

Those that seek perfection are destined to a life of search.
Those that seek 'working' are destined to a life of success...</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116652</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117080</id>
	<title>Re:Non-native English speakers</title>
	<author>mcgrew</author>
	<datestamp>1258394640000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><i>English is not most people's first language.</i></p><p>Neither is COBOL, Fortran, C, Java...</p></htmltext>
<tokenext>English is not most people 's first language.Neither is COBOL , Fortran , C , Java.. .</tokentext>
<sentencetext>English is not most people's first language.Neither is COBOL, Fortran, C, Java...</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116734</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120170</id>
	<title>Comment bugs and lack of comments a worse problem</title>
	<author>Anonymous</author>
	<datestamp>1258404120000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>2</modscore>
	<htmltext><p>Worst: Originally erroneous or out of date therefore  erroneous comments. Actively destructive to comprehension of the program, and once detected, causes all other comments in the program to be rejected as untrustworthy and worse than useless. "Comment Bug".</p><p>2nd Worst: No comments - indicates the developer either does not understand the purpose or method in their madness, or is lazy and sloppy. Either is very bad.</p><p>3rd worst: Redundant comments:<nobr> <wbr></nobr>/** Gets the Foo! */ Foo getFoo()   See Java api documentation for prime examples.</p><p>I would much rather read a long rambling philosophical comment that was essentially correct and did add some information than to deal with any of the above slackerware.</p></htmltext>
<tokenext>Worst : Originally erroneous or out of date therefore erroneous comments .
Actively destructive to comprehension of the program , and once detected , causes all other comments in the program to be rejected as untrustworthy and worse than useless .
" Comment Bug " .2nd Worst : No comments - indicates the developer either does not understand the purpose or method in their madness , or is lazy and sloppy .
Either is very bad.3rd worst : Redundant comments : / * * Gets the Foo !
* / Foo getFoo ( ) See Java api documentation for prime examples.I would much rather read a long rambling philosophical comment that was essentially correct and did add some information than to deal with any of the above slackerware .</tokentext>
<sentencetext>Worst: Originally erroneous or out of date therefore  erroneous comments.
Actively destructive to comprehension of the program, and once detected, causes all other comments in the program to be rejected as untrustworthy and worse than useless.
"Comment Bug".2nd Worst: No comments - indicates the developer either does not understand the purpose or method in their madness, or is lazy and sloppy.
Either is very bad.3rd worst: Redundant comments: /** Gets the Foo!
*/ Foo getFoo()   See Java api documentation for prime examples.I would much rather read a long rambling philosophical comment that was essentially correct and did add some information than to deal with any of the above slackerware.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30126196</id>
	<title>Re:Non-native English speakers</title>
	<author>Anonymous</author>
	<datestamp>1258397640000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>It really depends on the programmer.</p><p>I've seen code that was written by a Japanese guy, with all comments in Japanese - which turns out to be mostly machine-translatable (yay babelfish).  Given that he marked a few methods with "not impremented", I'm glad he did it in his native language.</p><p>Of course, it also ended up being that he had reasonably clean code and it was faster and easier to just ignore the comments...  English proficiency was definitely not tied to programming ability.</p></htmltext>
<tokenext>It really depends on the programmer.I 've seen code that was written by a Japanese guy , with all comments in Japanese - which turns out to be mostly machine-translatable ( yay babelfish ) .
Given that he marked a few methods with " not impremented " , I 'm glad he did it in his native language.Of course , it also ended up being that he had reasonably clean code and it was faster and easier to just ignore the comments... English proficiency was definitely not tied to programming ability .</tokentext>
<sentencetext>It really depends on the programmer.I've seen code that was written by a Japanese guy, with all comments in Japanese - which turns out to be mostly machine-translatable (yay babelfish).
Given that he marked a few methods with "not impremented", I'm glad he did it in his native language.Of course, it also ended up being that he had reasonably clean code and it was faster and easier to just ignore the comments...  English proficiency was definitely not tied to programming ability.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116734</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117090</id>
	<title>You are not expected to understand this</title>
	<author>wandazulu</author>
	<datestamp>1258394700000</datestamp>
	<modclass>Funny</modclass>
	<modscore>4</modscore>
	<htmltext><p>The granddaddy of WTF comments must come from the original Unix source, written by none other than Dennis Ritchie:<nobr> <wbr></nobr>/*<br>
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; * If the new process paused because it was<br>
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; * swapped out, set the stack level to the last call<br>
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; * to savu(u\_ssav).  This means that the return<br>
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; * which is executed immediately after the call to aretu<br>
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; * actually returns from the last routine which did<br>
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; * the savu.<br>
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; *<br>
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; * You are not expected to understand this.<br>
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; */<br>
&nbsp; &nbsp; &nbsp; &nbsp; if(rp-&gt;p\_flag&amp;SSWAP) {<br>
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; rp-&gt;p\_flag =&amp; ~SSWAP;<br>
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; aretu(u.u\_ssav);<br>
&nbsp; &nbsp; &nbsp; &nbsp; }</p><p>So here's an example of a comment that does an excellent (I assume) job of explaining why the code is doing what it's doing, yet the whole thing is so complicated that Ritchie even needed to acknowledge that the comment probably wasn't going to be of much help either with an amusing, and now somewhat famous, statement.</p></htmltext>
<tokenext>The granddaddy of WTF comments must come from the original Unix source , written by none other than Dennis Ritchie : / *           * If the new process paused because it was           * swapped out , set the stack level to the last call           * to savu ( u \ _ssav ) .
This means that the return           * which is executed immediately after the call to aretu           * actually returns from the last routine which did           * the savu .
          *           * You are not expected to understand this .
          * /         if ( rp- &gt; p \ _flag&amp;SSWAP ) {                 rp- &gt; p \ _flag = &amp; ~ SSWAP ;                 aretu ( u.u \ _ssav ) ;         } So here 's an example of a comment that does an excellent ( I assume ) job of explaining why the code is doing what it 's doing , yet the whole thing is so complicated that Ritchie even needed to acknowledge that the comment probably was n't going to be of much help either with an amusing , and now somewhat famous , statement .</tokentext>
<sentencetext>The granddaddy of WTF comments must come from the original Unix source, written by none other than Dennis Ritchie: /*
          * If the new process paused because it was
          * swapped out, set the stack level to the last call
          * to savu(u\_ssav).
This means that the return
          * which is executed immediately after the call to aretu
          * actually returns from the last routine which did
          * the savu.
          *
          * You are not expected to understand this.
          */
        if(rp-&gt;p\_flag&amp;SSWAP) {
                rp-&gt;p\_flag =&amp; ~SSWAP;
                aretu(u.u\_ssav);
        }So here's an example of a comment that does an excellent (I assume) job of explaining why the code is doing what it's doing, yet the whole thing is so complicated that Ritchie even needed to acknowledge that the comment probably wasn't going to be of much help either with an amusing, and now somewhat famous, statement.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30126672</id>
	<title>Golden Rule</title>
	<author>jumpfroggy</author>
	<datestamp>1258489920000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I think the golden rule applies here; do unto your code what you wish your predecessor's had done to their code.  If you write your own code, maintain it yourself, and never have anyone else work on it, then do whatever you want.  Heck, use no punctuation, indentation*, or even carriage returns if you can help it.</p><p>However, there seem to be two camps; those who see the value in comments, and those who don't.  Comments wont detract from those who don't like them (besides more trivial annoyances like wasted screen space), while the lack of comments may significantly hamper those who would appreciate it.  It seems safer &amp; more efficient to comment and make understandable code accessible to all, instead of saying that "good programmers" shouldn't need it, and raise the requirements unnecessarily  for the maintainability of your code.</p><p>Used properly, comments can help.  So just find a helpful way to do it.  My mindset is that I write for the next guy, assuming that someone's going to hand him the code with an explanation of what he should be doing, and the comments will help guide him.  They help the same way as chapter titles.  Chapter titles are unnecessary and often can be completely removed without altering the story.  But try to skim through a book and find what you're looking for w/o titles, and it's a pain.</p><p>I just jumped into an existing project that a genius (really) friend of mine started.  He's very smart, but not as experienced a programmer.  And the #1 pain point right now is lack of comments.  Some of the code is plain spaghetti.  That's fine, I'll just refactor it.  But since there's no comments describing *why* it's doing what it's doing, I can't yet refactor.</p><p>Other things work just fine.  But again, lack of comments prevents me from understanding what it's doing without understanding the entire context of the entire system.  This is bad design, but that's the point - perfect code may not need comments, but none of us need worry about that (since we wont be working on perfect code anytime soon).  It's not a crime to have rough code because the system is still organically growing.  It is to have tons of uncommented stuff jumbled together.</p><p>Help me to help you.  Help your successors maintain your crap.  Comment your code.  Make things easier on people (I'll put a 1 liner describing this section, since it's a little tricky), rather than harder (Really smart people will understand this, and I don't care about the others).</p><p>* Python users: find another way to obfuscate.</p></htmltext>
<tokenext>I think the golden rule applies here ; do unto your code what you wish your predecessor 's had done to their code .
If you write your own code , maintain it yourself , and never have anyone else work on it , then do whatever you want .
Heck , use no punctuation , indentation * , or even carriage returns if you can help it.However , there seem to be two camps ; those who see the value in comments , and those who do n't .
Comments wont detract from those who do n't like them ( besides more trivial annoyances like wasted screen space ) , while the lack of comments may significantly hamper those who would appreciate it .
It seems safer &amp; more efficient to comment and make understandable code accessible to all , instead of saying that " good programmers " should n't need it , and raise the requirements unnecessarily for the maintainability of your code.Used properly , comments can help .
So just find a helpful way to do it .
My mindset is that I write for the next guy , assuming that someone 's going to hand him the code with an explanation of what he should be doing , and the comments will help guide him .
They help the same way as chapter titles .
Chapter titles are unnecessary and often can be completely removed without altering the story .
But try to skim through a book and find what you 're looking for w/o titles , and it 's a pain.I just jumped into an existing project that a genius ( really ) friend of mine started .
He 's very smart , but not as experienced a programmer .
And the # 1 pain point right now is lack of comments .
Some of the code is plain spaghetti .
That 's fine , I 'll just refactor it .
But since there 's no comments describing * why * it 's doing what it 's doing , I ca n't yet refactor.Other things work just fine .
But again , lack of comments prevents me from understanding what it 's doing without understanding the entire context of the entire system .
This is bad design , but that 's the point - perfect code may not need comments , but none of us need worry about that ( since we wont be working on perfect code anytime soon ) .
It 's not a crime to have rough code because the system is still organically growing .
It is to have tons of uncommented stuff jumbled together.Help me to help you .
Help your successors maintain your crap .
Comment your code .
Make things easier on people ( I 'll put a 1 liner describing this section , since it 's a little tricky ) , rather than harder ( Really smart people will understand this , and I do n't care about the others ) .
* Python users : find another way to obfuscate .</tokentext>
<sentencetext>I think the golden rule applies here; do unto your code what you wish your predecessor's had done to their code.
If you write your own code, maintain it yourself, and never have anyone else work on it, then do whatever you want.
Heck, use no punctuation, indentation*, or even carriage returns if you can help it.However, there seem to be two camps; those who see the value in comments, and those who don't.
Comments wont detract from those who don't like them (besides more trivial annoyances like wasted screen space), while the lack of comments may significantly hamper those who would appreciate it.
It seems safer &amp; more efficient to comment and make understandable code accessible to all, instead of saying that "good programmers" shouldn't need it, and raise the requirements unnecessarily  for the maintainability of your code.Used properly, comments can help.
So just find a helpful way to do it.
My mindset is that I write for the next guy, assuming that someone's going to hand him the code with an explanation of what he should be doing, and the comments will help guide him.
They help the same way as chapter titles.
Chapter titles are unnecessary and often can be completely removed without altering the story.
But try to skim through a book and find what you're looking for w/o titles, and it's a pain.I just jumped into an existing project that a genius (really) friend of mine started.
He's very smart, but not as experienced a programmer.
And the #1 pain point right now is lack of comments.
Some of the code is plain spaghetti.
That's fine, I'll just refactor it.
But since there's no comments describing *why* it's doing what it's doing, I can't yet refactor.Other things work just fine.
But again, lack of comments prevents me from understanding what it's doing without understanding the entire context of the entire system.
This is bad design, but that's the point - perfect code may not need comments, but none of us need worry about that (since we wont be working on perfect code anytime soon).
It's not a crime to have rough code because the system is still organically growing.
It is to have tons of uncommented stuff jumbled together.Help me to help you.
Help your successors maintain your crap.
Comment your code.
Make things easier on people (I'll put a 1 liner describing this section, since it's a little tricky), rather than harder (Really smart people will understand this, and I don't care about the others).
* Python users: find another way to obfuscate.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116836</id>
	<title>Ascii Art?</title>
	<author>Spazed</author>
	<datestamp>1258393740000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext>That's it! I'm making all of my comments ascii art from now on!</htmltext>
<tokenext>That 's it !
I 'm making all of my comments ascii art from now on !</tokentext>
<sentencetext>That's it!
I'm making all of my comments ascii art from now on!</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30119754</id>
	<title>Re:The comment may also be complex..</title>
	<author>Anonymous</author>
	<datestamp>1258402860000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Hey, don't be too hard on the blue-collar...</p></htmltext>
<tokenext>Hey , do n't be too hard on the blue-collar.. .</tokentext>
<sentencetext>Hey, don't be too hard on the blue-collar...</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117028</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30149212</id>
	<title>Kneejerk Response</title>
	<author>pugugly</author>
	<datestamp>1257072720000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>This reminds me far too much of a Major I had in the Air Force that would spout off statements like "Shiny shoes make the missiles fly better!". Sadly the First Shirt was a political climber already known for citing technical definitions like "May means Will" in maintenance procedures to enforce completely unrelated things like "Posters in barracks <i>may</i> have a trim applied", and was happy to accommodate this imbecile.</p><p>Within six months we went from one of the Air Forces best flightlines to being concerned with BS stuff *all* *the* *time*. Maintenance didn't get done as fast, or as well - but hey, we had wonderful 'Team Building' Exercises among the newly promoted people with shiny shoes while morale circled around the drain.</p><p>None of which is to say that neatness isn't a valid skill to develop doing maintenance, or that good commenting isn't a good skill to develop in coding. But there is a style of failure I associate with over-emphasis on either.</p><p>Pug</p></htmltext>
<tokenext>This reminds me far too much of a Major I had in the Air Force that would spout off statements like " Shiny shoes make the missiles fly better ! " .
Sadly the First Shirt was a political climber already known for citing technical definitions like " May means Will " in maintenance procedures to enforce completely unrelated things like " Posters in barracks may have a trim applied " , and was happy to accommodate this imbecile.Within six months we went from one of the Air Forces best flightlines to being concerned with BS stuff * all * * the * * time * .
Maintenance did n't get done as fast , or as well - but hey , we had wonderful 'Team Building ' Exercises among the newly promoted people with shiny shoes while morale circled around the drain.None of which is to say that neatness is n't a valid skill to develop doing maintenance , or that good commenting is n't a good skill to develop in coding .
But there is a style of failure I associate with over-emphasis on either.Pug</tokentext>
<sentencetext>This reminds me far too much of a Major I had in the Air Force that would spout off statements like "Shiny shoes make the missiles fly better!".
Sadly the First Shirt was a political climber already known for citing technical definitions like "May means Will" in maintenance procedures to enforce completely unrelated things like "Posters in barracks may have a trim applied", and was happy to accommodate this imbecile.Within six months we went from one of the Air Forces best flightlines to being concerned with BS stuff *all* *the* *time*.
Maintenance didn't get done as fast, or as well - but hey, we had wonderful 'Team Building' Exercises among the newly promoted people with shiny shoes while morale circled around the drain.None of which is to say that neatness isn't a valid skill to develop doing maintenance, or that good commenting isn't a good skill to develop in coding.
But there is a style of failure I associate with over-emphasis on either.Pug</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118368</id>
	<title>Re:I'm an expert!</title>
	<author>Anonymous</author>
	<datestamp>1258398600000</datestamp>
	<modclass>Funny</modclass>
	<modscore>3</modscore>
	<htmltext><p>You forgot ass\_needs\_kicked = true and while(ass\_needs\_kicked).</p></htmltext>
<tokenext>You forgot ass \ _needs \ _kicked = true and while ( ass \ _needs \ _kicked ) .</tokentext>
<sentencetext>You forgot ass\_needs\_kicked = true and while(ass\_needs\_kicked).</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116778</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121092</id>
	<title>Re:You are not expected to understand this</title>
	<author>Anonymous</author>
	<datestamp>1258364460000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>1</modscore>
	<htmltext><p>The hero worship is getting rather tiresome. As someone who has dabbled in OS development, I understand what that is doing, though not for lack of obfuscation.</p><p>The biggest problem with that code is the lame function name, it's an abbreviation of something though I'm not sure what exactly [Might be <b>a</b>bsolute <b>retu</b>rn]; here is how I would have written that:</p><p><tt><nobr> <wbr></nobr>/* If the new process paused due to being swapped to disk<br>
&nbsp; * then wipe the stack call frames for all our parent callers<br>
&nbsp; * and return immediately all the way to the last function<br>
&nbsp; * to execute a stack state save.<br>
&nbsp; */<br>if (rp-&gt;flags &amp; PROCESS\_STATE\_SWAPPED) {<br>
&nbsp; &nbsp; &nbsp; &nbsp; rp-&gt;flags &amp;= ~PROCESS\_STATE\_SWAPPED;<br>
&nbsp; &nbsp; &nbsp; &nbsp; restore\_stack\_pointer(u.saved\_stack\_pointer);<br>}<br></tt><br>It's hard to be sure this is completely equivalent given the lame variable names but I am pretty sure this is what is happening; it's essentially a primitive setjmp/longjmp process. As to why, the comment is even more unhelpful in that regard; it looks like it's being used to throw an exception [before exception throwing existed] by returning all the way to the last function that registered a handler to deal with the swap out.</p></htmltext>
<tokenext>The hero worship is getting rather tiresome .
As someone who has dabbled in OS development , I understand what that is doing , though not for lack of obfuscation.The biggest problem with that code is the lame function name , it 's an abbreviation of something though I 'm not sure what exactly [ Might be absolute return ] ; here is how I would have written that : / * If the new process paused due to being swapped to disk   * then wipe the stack call frames for all our parent callers   * and return immediately all the way to the last function   * to execute a stack state save .
  * /if ( rp- &gt; flags &amp; PROCESS \ _STATE \ _SWAPPED ) {         rp- &gt; flags &amp; = ~ PROCESS \ _STATE \ _SWAPPED ;         restore \ _stack \ _pointer ( u.saved \ _stack \ _pointer ) ; } It 's hard to be sure this is completely equivalent given the lame variable names but I am pretty sure this is what is happening ; it 's essentially a primitive setjmp/longjmp process .
As to why , the comment is even more unhelpful in that regard ; it looks like it 's being used to throw an exception [ before exception throwing existed ] by returning all the way to the last function that registered a handler to deal with the swap out .</tokentext>
<sentencetext>The hero worship is getting rather tiresome.
As someone who has dabbled in OS development, I understand what that is doing, though not for lack of obfuscation.The biggest problem with that code is the lame function name, it's an abbreviation of something though I'm not sure what exactly [Might be absolute return]; here is how I would have written that: /* If the new process paused due to being swapped to disk
  * then wipe the stack call frames for all our parent callers
  * and return immediately all the way to the last function
  * to execute a stack state save.
  */if (rp-&gt;flags &amp; PROCESS\_STATE\_SWAPPED) {
        rp-&gt;flags &amp;= ~PROCESS\_STATE\_SWAPPED;
        restore\_stack\_pointer(u.saved\_stack\_pointer);}It's hard to be sure this is completely equivalent given the lame variable names but I am pretty sure this is what is happening; it's essentially a primitive setjmp/longjmp process.
As to why, the comment is even more unhelpful in that regard; it looks like it's being used to throw an exception [before exception throwing existed] by returning all the way to the last function that registered a handler to deal with the swap out.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117090</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118354</id>
	<title>Nit picking</title>
	<author>EmperorOfCanada</author>
	<datestamp>1258398600000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>I agree that coders should not be sloppy. "Ah the user will never hit return more than once" but outside of a mission critical application nit picking is a great way to never get anything done. The most successful companies generally have the approach of "Let's put some lipstick on this pig and get it out of here." While not being the statement of a careful craftsman it is what gets the bills paid.</htmltext>
<tokenext>I agree that coders should not be sloppy .
" Ah the user will never hit return more than once " but outside of a mission critical application nit picking is a great way to never get anything done .
The most successful companies generally have the approach of " Let 's put some lipstick on this pig and get it out of here .
" While not being the statement of a careful craftsman it is what gets the bills paid .</tokentext>
<sentencetext>I agree that coders should not be sloppy.
"Ah the user will never hit return more than once" but outside of a mission critical application nit picking is a great way to never get anything done.
The most successful companies generally have the approach of "Let's put some lipstick on this pig and get it out of here.
" While not being the statement of a careful craftsman it is what gets the bills paid.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30126682</id>
	<title>Re:I agree, with reservations</title>
	<author>prichardson</author>
	<datestamp>1258490040000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>People who learn english as a second language are less likely to make that mistake because the mistake comes from them sounding the same.  Usually second languages are learned as much from reading as from speaking, so the difference is clearer.</p></htmltext>
<tokenext>People who learn english as a second language are less likely to make that mistake because the mistake comes from them sounding the same .
Usually second languages are learned as much from reading as from speaking , so the difference is clearer .</tokentext>
<sentencetext>People who learn english as a second language are less likely to make that mistake because the mistake comes from them sounding the same.
Usually second languages are learned as much from reading as from speaking, so the difference is clearer.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116868</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121434</id>
	<title>Re:I agree, with reservations</title>
	<author>JustNiz</author>
	<datestamp>1258365900000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>You're making the same mistakes as many other software engineers by allowing yourself to be walked all over by sales.<br>Did you ever stop to think that you're actually being less productive by working 80 hour weeks and throwing out low-quality stuff?<br>All that rework...<br>If its really you talking to the salesman and not your boss, then you've already sold your own ass down the river by continually giving the sales guys what they want all the time at the cost of your own life. You need to train the sales guys to not turn up at your desk and expect/demand the impossible, but to involve you early at the negotiation time with the customer so your input into realistic deadlines gets considered BEFORE they make commitments you cant keep to the customer.</p></htmltext>
<tokenext>You 're making the same mistakes as many other software engineers by allowing yourself to be walked all over by sales.Did you ever stop to think that you 're actually being less productive by working 80 hour weeks and throwing out low-quality stuff ? All that rework...If its really you talking to the salesman and not your boss , then you 've already sold your own ass down the river by continually giving the sales guys what they want all the time at the cost of your own life .
You need to train the sales guys to not turn up at your desk and expect/demand the impossible , but to involve you early at the negotiation time with the customer so your input into realistic deadlines gets considered BEFORE they make commitments you cant keep to the customer .</tokentext>
<sentencetext>You're making the same mistakes as many other software engineers by allowing yourself to be walked all over by sales.Did you ever stop to think that you're actually being less productive by working 80 hour weeks and throwing out low-quality stuff?All that rework...If its really you talking to the salesman and not your boss, then you've already sold your own ass down the river by continually giving the sales guys what they want all the time at the cost of your own life.
You need to train the sales guys to not turn up at your desk and expect/demand the impossible, but to involve you early at the negotiation time with the customer so your input into realistic deadlines gets considered BEFORE they make commitments you cant keep to the customer.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117648</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30136066</id>
	<title>Re:Comments are for future maintainers</title>
	<author>tieTYT</author>
	<datestamp>1258456800000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><blockquote><div><p> <tt>i += 4;<nobr> <wbr></nobr>/* Increment i by 4 */ BAD comment</tt></p><p><tt>i += 4;<nobr> <wbr></nobr>/* Ignore the first 4 fields */ Better</tt> </p></div></blockquote></div><p>ignoreFirst4Fields();<nobr> <wbr></nobr>/* even better than that? */</p></div>
	</htmltext>
<tokenext>i + = 4 ; / * Increment i by 4 * / BAD commenti + = 4 ; / * Ignore the first 4 fields * / Better ignoreFirst4Fields ( ) ; / * even better than that ?
* /</tokentext>
<sentencetext> i += 4; /* Increment i by 4 */ BAD commenti += 4; /* Ignore the first 4 fields */ Better ignoreFirst4Fields(); /* even better than that?
*/
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117366</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116970</id>
	<title>Re:Well, duh.</title>
	<author>Eudial</author>
	<datestamp>1258394160000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>That's also why I don't comment my code.</p></div><p>This is a good practice. Comments very seldom keep up with changes in the code base, so more often than not, they end up being misleading at some point in the future.</p><p>The reason people think they need to cluster bomb their code with comments is generally because they have a degree in CS, and CS classes often require such code. But that's because the professor (or rather, the TA:s) need to quickly read through 50 or so computer lab reports every couple of weeks, and doing so without comments takes ages (especially what with the more dubious code that occasionally gets handed in.)</p><p>Documenting module interfaces is generally a good thing, but actually littering the implementation with comments is quite another (unless there is some outstanding reason to do so).</p></div>
	</htmltext>
<tokenext>That 's also why I do n't comment my code.This is a good practice .
Comments very seldom keep up with changes in the code base , so more often than not , they end up being misleading at some point in the future.The reason people think they need to cluster bomb their code with comments is generally because they have a degree in CS , and CS classes often require such code .
But that 's because the professor ( or rather , the TA : s ) need to quickly read through 50 or so computer lab reports every couple of weeks , and doing so without comments takes ages ( especially what with the more dubious code that occasionally gets handed in .
) Documenting module interfaces is generally a good thing , but actually littering the implementation with comments is quite another ( unless there is some outstanding reason to do so ) .</tokentext>
<sentencetext>That's also why I don't comment my code.This is a good practice.
Comments very seldom keep up with changes in the code base, so more often than not, they end up being misleading at some point in the future.The reason people think they need to cluster bomb their code with comments is generally because they have a degree in CS, and CS classes often require such code.
But that's because the professor (or rather, the TA:s) need to quickly read through 50 or so computer lab reports every couple of weeks, and doing so without comments takes ages (especially what with the more dubious code that occasionally gets handed in.
)Documenting module interfaces is generally a good thing, but actually littering the implementation with comments is quite another (unless there is some outstanding reason to do so).
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116680</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116652</id>
	<title>Re:The comment may also be complex..</title>
	<author>Rick the Red</author>
	<datestamp>1258393140000</datestamp>
	<modclass>Funny</modclass>
	<modscore>4</modscore>
	<htmltext><p>I once coded a function that varied depending on what quadrant (+x,+y; -x, +y; -x,-y; +x,-y) it was in. I couldn't get it to work right in the second quadrant, but finally got it working by chance and said so in my comments. The code worked, but I didn't understand why and said so. Is that bad coding? It worked!</p></htmltext>
<tokenext>I once coded a function that varied depending on what quadrant ( + x , + y ; -x , + y ; -x,-y ; + x,-y ) it was in .
I could n't get it to work right in the second quadrant , but finally got it working by chance and said so in my comments .
The code worked , but I did n't understand why and said so .
Is that bad coding ?
It worked !</tokentext>
<sentencetext>I once coded a function that varied depending on what quadrant (+x,+y; -x, +y; -x,-y; +x,-y) it was in.
I couldn't get it to work right in the second quadrant, but finally got it working by chance and said so in my comments.
The code worked, but I didn't understand why and said so.
Is that bad coding?
It worked!</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116558</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117362</id>
	<title>Re:Well, duh.</title>
	<author>McNihil</author>
	<datestamp>1258395780000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Natural language in code tend to distract at best and mislead at worst. Also when coding is done with users writing comments in their preferred natural language (and character set) it just goes to hell.</p><p>If the code is not clear to understand then it should be re-written so that it is much clearer. Spending time writing clear code is far more superior than writing bibles of comments because no matter what you write in the comment there will be bugs in the code.</p><p>If I get unknown code from anyone I ALWAYS strip out the comments... the comments mean nothing to me... the code does mean everything... also one gets to understand how the original author was thinking... thus knowing where they most likely would have coded wrong and where there is a problem with the data structure.</p><p>Comments were useful back in the day when the code base was very small and a manager could potentially feel good by reading pages and pages of commented source code... this however is mere self gratification for the managers and has nothing to do with how good code really is. I'd rather have good code than code that is commented well so that a lay person can "read the code."</p></htmltext>
<tokenext>Natural language in code tend to distract at best and mislead at worst .
Also when coding is done with users writing comments in their preferred natural language ( and character set ) it just goes to hell.If the code is not clear to understand then it should be re-written so that it is much clearer .
Spending time writing clear code is far more superior than writing bibles of comments because no matter what you write in the comment there will be bugs in the code.If I get unknown code from anyone I ALWAYS strip out the comments... the comments mean nothing to me... the code does mean everything... also one gets to understand how the original author was thinking... thus knowing where they most likely would have coded wrong and where there is a problem with the data structure.Comments were useful back in the day when the code base was very small and a manager could potentially feel good by reading pages and pages of commented source code... this however is mere self gratification for the managers and has nothing to do with how good code really is .
I 'd rather have good code than code that is commented well so that a lay person can " read the code .
"</tokentext>
<sentencetext>Natural language in code tend to distract at best and mislead at worst.
Also when coding is done with users writing comments in their preferred natural language (and character set) it just goes to hell.If the code is not clear to understand then it should be re-written so that it is much clearer.
Spending time writing clear code is far more superior than writing bibles of comments because no matter what you write in the comment there will be bugs in the code.If I get unknown code from anyone I ALWAYS strip out the comments... the comments mean nothing to me... the code does mean everything... also one gets to understand how the original author was thinking... thus knowing where they most likely would have coded wrong and where there is a problem with the data structure.Comments were useful back in the day when the code base was very small and a manager could potentially feel good by reading pages and pages of commented source code... this however is mere self gratification for the managers and has nothing to do with how good code really is.
I'd rather have good code than code that is commented well so that a lay person can "read the code.
"</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116970</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116926</id>
	<title>All I can say is "few anecdotes don't make data"</title>
	<author>Anonymous</author>
	<datestamp>1258393980000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>All I can say is "few anecdotes don't make data"</p></htmltext>
<tokenext>All I can say is " few anecdotes do n't make data "</tokentext>
<sentencetext>All I can say is "few anecdotes don't make data"</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117812</id>
	<title>Here's an idea</title>
	<author>xtrafe</author>
	<datestamp>1258396980000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Let's invent a machine that is based on mathematical logic, that can only interpret simple instructions, but executes those instructions precisely and with no ambiguity. Then, since human language is fuzzy and full of ambiguity (like human minds), lets invent languages that are extremely specific, so that it will be easy for us to tell our new machines what to do. Finally lets go through the laborious task of translating our fuzzy ambiguous thoughts into these rigid, well qualified languages...</p><p>...now we've accomplished all that, lets take all our hard work and undo it. Lets back-work a bunch of fuzzy ambiguous language over the well-specified one, creating a mish-mosh of two languages: logical human and illogical human. That sounds like a good idea, because what we really need is to say everything, and then say it again badly.</p><p>Commenting is highly overrated, and a lot of people have been indoctrinated by teachers that have little work experience. The adherence to code commenting stems partially from it being a first-pass attempt to avoid the shortcomings of a waterfall development process. Now we can do better. <a href="http://en.wikipedia.org/wiki/Agile\_development" title="wikipedia.org" rel="nofollow">We prefer functionality over documentation.</a> [wikipedia.org] Well written code should be transparent to a seasoned developer. If it is not, see the two qualifications in the previous sentence. Commenting usually just mis-specifies what's going on, lets people get away with writing sloppy code, and <b>encourages people to not read code that they ought to</b>.</p><p> <i>The main exception to the above is the documentation of API interfaces, which is really an extension of the concept of encapsulation. In this case, the developer really shouldn't have to read the code in question (though in practice one always winds up having to read a little). </i> </p></htmltext>
<tokenext>Let 's invent a machine that is based on mathematical logic , that can only interpret simple instructions , but executes those instructions precisely and with no ambiguity .
Then , since human language is fuzzy and full of ambiguity ( like human minds ) , lets invent languages that are extremely specific , so that it will be easy for us to tell our new machines what to do .
Finally lets go through the laborious task of translating our fuzzy ambiguous thoughts into these rigid , well qualified languages......now we 've accomplished all that , lets take all our hard work and undo it .
Lets back-work a bunch of fuzzy ambiguous language over the well-specified one , creating a mish-mosh of two languages : logical human and illogical human .
That sounds like a good idea , because what we really need is to say everything , and then say it again badly.Commenting is highly overrated , and a lot of people have been indoctrinated by teachers that have little work experience .
The adherence to code commenting stems partially from it being a first-pass attempt to avoid the shortcomings of a waterfall development process .
Now we can do better .
We prefer functionality over documentation .
[ wikipedia.org ] Well written code should be transparent to a seasoned developer .
If it is not , see the two qualifications in the previous sentence .
Commenting usually just mis-specifies what 's going on , lets people get away with writing sloppy code , and encourages people to not read code that they ought to .
The main exception to the above is the documentation of API interfaces , which is really an extension of the concept of encapsulation .
In this case , the developer really should n't have to read the code in question ( though in practice one always winds up having to read a little ) .</tokentext>
<sentencetext>Let's invent a machine that is based on mathematical logic, that can only interpret simple instructions, but executes those instructions precisely and with no ambiguity.
Then, since human language is fuzzy and full of ambiguity (like human minds), lets invent languages that are extremely specific, so that it will be easy for us to tell our new machines what to do.
Finally lets go through the laborious task of translating our fuzzy ambiguous thoughts into these rigid, well qualified languages......now we've accomplished all that, lets take all our hard work and undo it.
Lets back-work a bunch of fuzzy ambiguous language over the well-specified one, creating a mish-mosh of two languages: logical human and illogical human.
That sounds like a good idea, because what we really need is to say everything, and then say it again badly.Commenting is highly overrated, and a lot of people have been indoctrinated by teachers that have little work experience.
The adherence to code commenting stems partially from it being a first-pass attempt to avoid the shortcomings of a waterfall development process.
Now we can do better.
We prefer functionality over documentation.
[wikipedia.org] Well written code should be transparent to a seasoned developer.
If it is not, see the two qualifications in the previous sentence.
Commenting usually just mis-specifies what's going on, lets people get away with writing sloppy code, and encourages people to not read code that they ought to.
The main exception to the above is the documentation of API interfaces, which is really an extension of the concept of encapsulation.
In this case, the developer really shouldn't have to read the code in question (though in practice one always winds up having to read a little).  </sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118074</id>
	<title>I don't understand</title>
	<author>PPH</author>
	<datestamp>1258397820000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>What are these things you people call comments?</htmltext>
<tokenext>What are these things you people call comments ?</tokentext>
<sentencetext>What are these things you people call comments?</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30125652</id>
	<title>Re:I agree, with reservations</title>
	<author>bidule</author>
	<datestamp>1258391340000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I totally agree with you.</p><p>The big joke is that when you see crappy written English, you know it's a native.</p><p>"Ce qui se con&#231;oit bien s'&#233;nonce clairement et les mots pour le dire arrivent ais&#233;ment" - Boileau</p><p>I will add that if you cannot grok your own native language, which you've used to 20+ years, how can you affirm that you understand a programming language. If you cannot make an instantaneous difference between a subject/verb pair, a pronoun and an adverb, why should I trust you'll know the difference between lvalue and rvalue?</p></htmltext>
<tokenext>I totally agree with you.The big joke is that when you see crappy written English , you know it 's a native .
" Ce qui se con   oit bien s '   nonce clairement et les mots pour le dire arrivent ais   ment " - BoileauI will add that if you can not grok your own native language , which you 've used to 20 + years , how can you affirm that you understand a programming language .
If you can not make an instantaneous difference between a subject/verb pair , a pronoun and an adverb , why should I trust you 'll know the difference between lvalue and rvalue ?</tokentext>
<sentencetext>I totally agree with you.The big joke is that when you see crappy written English, you know it's a native.
"Ce qui se conçoit bien s'énonce clairement et les mots pour le dire arrivent aisément" - BoileauI will add that if you cannot grok your own native language, which you've used to 20+ years, how can you affirm that you understand a programming language.
If you cannot make an instantaneous difference between a subject/verb pair, a pronoun and an adverb, why should I trust you'll know the difference between lvalue and rvalue?</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116868</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116538</id>
	<title>Becoming a Nigger</title>
	<author>Anonymous</author>
	<datestamp>1258392600000</datestamp>
	<modclass>Troll</modclass>
	<modscore>-1</modscore>
	<htmltext><b>HOW TO BE A WORTHLESS, VILE, AMERICAN YARD-APE!!!!</b> <ul>
<li>Slink around, shuffling your feet and bobbing your neck like the lazy retard you are.</li><li>Walk down the middle of the street because you don't know what a sidewalk is for.</li><li>Hang out at carwashes and mini-marts because everybody knows these are the best places to be a dope, I mean dope.</li><li>If you're a nigger bitch, shit three nigger babies into the world before 17 years of age. This assures that welfare money will support you, so
your nigger men have more time to commit crimes.</li><li>And give REAL honest black people a bad name.</li><li>Oh yes, make sure each nigger baby has a different father.</li><li>Bastardize the English language in the name of nigger culture.</li><li>Make sure that several terms have multiple meanings and others have ambiguous meanings and that only 50\% of nigger words are even complete
words.  Real niggers will know what you're trying to say.</li><li>As a culture, make sure there are always more blacks in prison than in college at any given time.</li><li>Hang out in packs of 10 to 15 and make sure everyone acts as annoying as possible. This helps to promote nigger individuality.</li><li>Always talk loud enough so everyone in the 'hood can fucking hear you, and if they are niggers, they will know what your saying, bro.</li><li>Wear clothes that are 10 sizes too big, making sure the pants hang off your ass.</li><li>Park at least 5 junk cars in your yard while being careful not to use the driveway. It's OK to abandon them in the street as long as it's
in front of someone else's crib.</li><li>Exaggerate every motion, every tonal inflection and grab your dick a lot.</li><li>Do drugs, sell drugs, make drugs.  Okay, don't REALLY do this, but it IS what niggers do.</li><li>Turn your backyard into a junk yard. If you don't have a backyard, turn your mother's into a junk yard.</li><li>Travel around leaching off relatives, friends, salvation armies.</li><li>Drink cheap wine and malt liquor every day, forgetting that "malt liquor" is just fortified cheap beer.</li><li>If you're a nigger buck: fuck anything that moves, no matter how ugly she is. After two 40oz, even the ugliest, fattest nigger bitch will look
good.</li><li>Be charitable and covet fat, ugly white chicks. After all, they're niggers too. They can't help being so undesirable to white men that they have
to fraternize with black dudes on a 20/20 trip. And white ho's are a special trophy too, especially the not so ugly ones.</li><li>Spray paint everything in sight with scribbles that mean nothing to white people but mean things to fellow niggers (except niggers from another
hood who will probably go after you for tresspassing on their turf).</li><li>Use the term "motherfucker" in every sentence. It's one of the most versatile words in the nigger language, being a noun, verb, adjective
and complete mini-sentence in event you run out of thoughts.</li><li>Stop in the middle of the street, blocking all traffic to converse with fellow niggers and have complete disregard for everyone else.</li><li>Overcharge customers at Taco Bell and pocket the difference.</li><li>Drive your car while slouched so low that you can barely see over the wheel (gangsta drivin').</li><li>Get a job under affirmative action. Then sit around all day pretending that you earned the position and that the other co-workers respect you.
Whenever you fuck up, scream "racism!" &amp; hope you get enough Generation X liberals in the jury.</li><li>Never, I mean NEVER, take any responsibility for your actions. Always blame others including Asians, Latinos, Mexicans, and especially
Whites for your sorry ass stupid lives.</li><li>Be sure to get a dog, tie it up in the cold and mud and neglect it until it dies. Then start all over again. Cash must be used because you long
ago fucked up your credit and checking account.</li><li>Cram 5 generations into a two room government apartment and still be able to neglect your kids.</li></ul><p>
Then you too can be a true nigger, and anyone who finds any fault with anything yo</p></htmltext>
<tokenext>HOW TO BE A WORTHLESS , VILE , AMERICAN YARD-APE ! ! ! !
Slink around , shuffling your feet and bobbing your neck like the lazy retard you are.Walk down the middle of the street because you do n't know what a sidewalk is for.Hang out at carwashes and mini-marts because everybody knows these are the best places to be a dope , I mean dope.If you 're a nigger bitch , shit three nigger babies into the world before 17 years of age .
This assures that welfare money will support you , so your nigger men have more time to commit crimes.And give REAL honest black people a bad name.Oh yes , make sure each nigger baby has a different father.Bastardize the English language in the name of nigger culture.Make sure that several terms have multiple meanings and others have ambiguous meanings and that only 50 \ % of nigger words are even complete words .
Real niggers will know what you 're trying to say.As a culture , make sure there are always more blacks in prison than in college at any given time.Hang out in packs of 10 to 15 and make sure everyone acts as annoying as possible .
This helps to promote nigger individuality.Always talk loud enough so everyone in the 'hood can fucking hear you , and if they are niggers , they will know what your saying , bro.Wear clothes that are 10 sizes too big , making sure the pants hang off your ass.Park at least 5 junk cars in your yard while being careful not to use the driveway .
It 's OK to abandon them in the street as long as it 's in front of someone else 's crib.Exaggerate every motion , every tonal inflection and grab your dick a lot.Do drugs , sell drugs , make drugs .
Okay , do n't REALLY do this , but it IS what niggers do.Turn your backyard into a junk yard .
If you do n't have a backyard , turn your mother 's into a junk yard.Travel around leaching off relatives , friends , salvation armies.Drink cheap wine and malt liquor every day , forgetting that " malt liquor " is just fortified cheap beer.If you 're a nigger buck : fuck anything that moves , no matter how ugly she is .
After two 40oz , even the ugliest , fattest nigger bitch will look good.Be charitable and covet fat , ugly white chicks .
After all , they 're niggers too .
They ca n't help being so undesirable to white men that they have to fraternize with black dudes on a 20/20 trip .
And white ho 's are a special trophy too , especially the not so ugly ones.Spray paint everything in sight with scribbles that mean nothing to white people but mean things to fellow niggers ( except niggers from another hood who will probably go after you for tresspassing on their turf ) .Use the term " motherfucker " in every sentence .
It 's one of the most versatile words in the nigger language , being a noun , verb , adjective and complete mini-sentence in event you run out of thoughts.Stop in the middle of the street , blocking all traffic to converse with fellow niggers and have complete disregard for everyone else.Overcharge customers at Taco Bell and pocket the difference.Drive your car while slouched so low that you can barely see over the wheel ( gangsta drivin ' ) .Get a job under affirmative action .
Then sit around all day pretending that you earned the position and that the other co-workers respect you .
Whenever you fuck up , scream " racism !
" &amp; hope you get enough Generation X liberals in the jury.Never , I mean NEVER , take any responsibility for your actions .
Always blame others including Asians , Latinos , Mexicans , and especially Whites for your sorry ass stupid lives.Be sure to get a dog , tie it up in the cold and mud and neglect it until it dies .
Then start all over again .
Cash must be used because you long ago fucked up your credit and checking account.Cram 5 generations into a two room government apartment and still be able to neglect your kids .
Then you too can be a true nigger , and anyone who finds any fault with anything yo</tokentext>
<sentencetext>HOW TO BE A WORTHLESS, VILE, AMERICAN YARD-APE!!!!
Slink around, shuffling your feet and bobbing your neck like the lazy retard you are.Walk down the middle of the street because you don't know what a sidewalk is for.Hang out at carwashes and mini-marts because everybody knows these are the best places to be a dope, I mean dope.If you're a nigger bitch, shit three nigger babies into the world before 17 years of age.
This assures that welfare money will support you, so
your nigger men have more time to commit crimes.And give REAL honest black people a bad name.Oh yes, make sure each nigger baby has a different father.Bastardize the English language in the name of nigger culture.Make sure that several terms have multiple meanings and others have ambiguous meanings and that only 50\% of nigger words are even complete
words.
Real niggers will know what you're trying to say.As a culture, make sure there are always more blacks in prison than in college at any given time.Hang out in packs of 10 to 15 and make sure everyone acts as annoying as possible.
This helps to promote nigger individuality.Always talk loud enough so everyone in the 'hood can fucking hear you, and if they are niggers, they will know what your saying, bro.Wear clothes that are 10 sizes too big, making sure the pants hang off your ass.Park at least 5 junk cars in your yard while being careful not to use the driveway.
It's OK to abandon them in the street as long as it's
in front of someone else's crib.Exaggerate every motion, every tonal inflection and grab your dick a lot.Do drugs, sell drugs, make drugs.
Okay, don't REALLY do this, but it IS what niggers do.Turn your backyard into a junk yard.
If you don't have a backyard, turn your mother's into a junk yard.Travel around leaching off relatives, friends, salvation armies.Drink cheap wine and malt liquor every day, forgetting that "malt liquor" is just fortified cheap beer.If you're a nigger buck: fuck anything that moves, no matter how ugly she is.
After two 40oz, even the ugliest, fattest nigger bitch will look
good.Be charitable and covet fat, ugly white chicks.
After all, they're niggers too.
They can't help being so undesirable to white men that they have
to fraternize with black dudes on a 20/20 trip.
And white ho's are a special trophy too, especially the not so ugly ones.Spray paint everything in sight with scribbles that mean nothing to white people but mean things to fellow niggers (except niggers from another
hood who will probably go after you for tresspassing on their turf).Use the term "motherfucker" in every sentence.
It's one of the most versatile words in the nigger language, being a noun, verb, adjective
and complete mini-sentence in event you run out of thoughts.Stop in the middle of the street, blocking all traffic to converse with fellow niggers and have complete disregard for everyone else.Overcharge customers at Taco Bell and pocket the difference.Drive your car while slouched so low that you can barely see over the wheel (gangsta drivin').Get a job under affirmative action.
Then sit around all day pretending that you earned the position and that the other co-workers respect you.
Whenever you fuck up, scream "racism!
" &amp; hope you get enough Generation X liberals in the jury.Never, I mean NEVER, take any responsibility for your actions.
Always blame others including Asians, Latinos, Mexicans, and especially
Whites for your sorry ass stupid lives.Be sure to get a dog, tie it up in the cold and mud and neglect it until it dies.
Then start all over again.
Cash must be used because you long
ago fucked up your credit and checking account.Cram 5 generations into a two room government apartment and still be able to neglect your kids.
Then you too can be a true nigger, and anyone who finds any fault with anything yo</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117720</id>
	<title>Re:Existence of Comments</title>
	<author>tgrigsby</author>
	<datestamp>1258396740000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><i>If comments even exist, then the code is ugly. Code should document itself.</i></p><p>The tragic part about your comment is that there are so many people out there that don't know it's just a joke.  It's the same crowd that thinks that Saddam hid his WMDs in Syria and that the House healthcare bill would legalize "death panels" and will never be convinced otherwise.</p></htmltext>
<tokenext>If comments even exist , then the code is ugly .
Code should document itself.The tragic part about your comment is that there are so many people out there that do n't know it 's just a joke .
It 's the same crowd that thinks that Saddam hid his WMDs in Syria and that the House healthcare bill would legalize " death panels " and will never be convinced otherwise .</tokentext>
<sentencetext>If comments even exist, then the code is ugly.
Code should document itself.The tragic part about your comment is that there are so many people out there that don't know it's just a joke.
It's the same crowd that thinks that Saddam hid his WMDs in Syria and that the House healthcare bill would legalize "death panels" and will never be convinced otherwise.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116872</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116672</id>
	<title>Long-winded comments can be very useful</title>
	<author>JoshuaZ</author>
	<datestamp>1258393200000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>5</modscore>
	<htmltext>I sometimes write code for number theory algorithms. Often short-cuts and little speed ups have long proofs to justify why they work. If I expect the code to be used/read by other people I'll often include these explanations (and so I don't need to bother convincing myself later if I look at the code a year later). There's nothing wrong with long comments. Moreover, given a negative attitude towards long comments, many bad programmers will likely simply respond by not commenting their code at all. That's not good.</htmltext>
<tokenext>I sometimes write code for number theory algorithms .
Often short-cuts and little speed ups have long proofs to justify why they work .
If I expect the code to be used/read by other people I 'll often include these explanations ( and so I do n't need to bother convincing myself later if I look at the code a year later ) .
There 's nothing wrong with long comments .
Moreover , given a negative attitude towards long comments , many bad programmers will likely simply respond by not commenting their code at all .
That 's not good .</tokentext>
<sentencetext>I sometimes write code for number theory algorithms.
Often short-cuts and little speed ups have long proofs to justify why they work.
If I expect the code to be used/read by other people I'll often include these explanations (and so I don't need to bother convincing myself later if I look at the code a year later).
There's nothing wrong with long comments.
Moreover, given a negative attitude towards long comments, many bad programmers will likely simply respond by not commenting their code at all.
That's not good.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117088</id>
	<title>Forced to use Bad API</title>
	<author>Baby Duck</author>
	<datestamp>1258394700000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>2</modscore>
	<htmltext>If I have a long comment explaining "magic", 99 times out of 100 it's because I'm being forced to interface with a bad API which THAT CODER didn't properly understand. Glaring errors in the documentation, unexpected outputs, unexpected hangups<nobr> <wbr></nobr>... these are my duty to comment about. Of course I don't understand why the API is malfunctioning<nobr> <wbr></nobr>... it's a BLACK BOX. My employer might be too much of a cheapskate to purchase product support to troubleshoot the API. Or the vendor might charge outrageous support fees for their mess ups. I cannot switch to a different API, because I do not have the authority to make that decision.

My comments are self-defense when backed up against the wall. It does nothing to gauge my programming ability.</htmltext>
<tokenext>If I have a long comment explaining " magic " , 99 times out of 100 it 's because I 'm being forced to interface with a bad API which THAT CODER did n't properly understand .
Glaring errors in the documentation , unexpected outputs , unexpected hangups ... these are my duty to comment about .
Of course I do n't understand why the API is malfunctioning ... it 's a BLACK BOX .
My employer might be too much of a cheapskate to purchase product support to troubleshoot the API .
Or the vendor might charge outrageous support fees for their mess ups .
I can not switch to a different API , because I do not have the authority to make that decision .
My comments are self-defense when backed up against the wall .
It does nothing to gauge my programming ability .</tokentext>
<sentencetext>If I have a long comment explaining "magic", 99 times out of 100 it's because I'm being forced to interface with a bad API which THAT CODER didn't properly understand.
Glaring errors in the documentation, unexpected outputs, unexpected hangups ... these are my duty to comment about.
Of course I don't understand why the API is malfunctioning ... it's a BLACK BOX.
My employer might be too much of a cheapskate to purchase product support to troubleshoot the API.
Or the vendor might charge outrageous support fees for their mess ups.
I cannot switch to a different API, because I do not have the authority to make that decision.
My comments are self-defense when backed up against the wall.
It does nothing to gauge my programming ability.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30119230</id>
	<title>Re:Existence of Comments</title>
	<author>Anonymous</author>
	<datestamp>1258401240000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Right! Who needs comments on complex regular expressions?</p></htmltext>
<tokenext>Right !
Who needs comments on complex regular expressions ?</tokentext>
<sentencetext>Right!
Who needs comments on complex regular expressions?</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116872</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116696</id>
	<title>See Previous Story: Agile Is</title>
	<author>Anonymous</author>
	<datestamp>1258393260000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>NOT using MicroSLOP.  I 'm sure you the know the intended reference.</p><p>Yours In Astrakhan,<br>K. Trout</p></htmltext>
<tokenext>NOT using MicroSLOP .
I 'm sure you the know the intended reference.Yours In Astrakhan,K .
Trout</tokentext>
<sentencetext>NOT using MicroSLOP.
I 'm sure you the know the intended reference.Yours In Astrakhan,K.
Trout</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117246</id>
	<title>Re:Existence of Comments</title>
	<author>linuxgurugamer</author>
	<datestamp>1258395300000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Sorry, you're wrong.</p><p>30 years of programming, for a variety of companies, tells me that.</p><p>When I have to look at someone else's code, it helps if, for example, each function has a set of comments which briefly describes what the function is, the parameters it is expecting, and what it is returning.  Even if you wrote "self-documenting" code, it never documents itself enough.</p><p>Speaking of Perl, it is one of the worst languages for documentation.  When I see it, I will either spend time figuring out what it is trying to do and document it, or not use it.  I will not use code which I don't understand, because then I can't debug it.  Comments help in that.</p><p>Also, sometimes comments will document a history of changes, and may explain why the code is doing something a certain way.</p></htmltext>
<tokenext>Sorry , you 're wrong.30 years of programming , for a variety of companies , tells me that.When I have to look at someone else 's code , it helps if , for example , each function has a set of comments which briefly describes what the function is , the parameters it is expecting , and what it is returning .
Even if you wrote " self-documenting " code , it never documents itself enough.Speaking of Perl , it is one of the worst languages for documentation .
When I see it , I will either spend time figuring out what it is trying to do and document it , or not use it .
I will not use code which I do n't understand , because then I ca n't debug it .
Comments help in that.Also , sometimes comments will document a history of changes , and may explain why the code is doing something a certain way .</tokentext>
<sentencetext>Sorry, you're wrong.30 years of programming, for a variety of companies, tells me that.When I have to look at someone else's code, it helps if, for example, each function has a set of comments which briefly describes what the function is, the parameters it is expecting, and what it is returning.
Even if you wrote "self-documenting" code, it never documents itself enough.Speaking of Perl, it is one of the worst languages for documentation.
When I see it, I will either spend time figuring out what it is trying to do and document it, or not use it.
I will not use code which I don't understand, because then I can't debug it.
Comments help in that.Also, sometimes comments will document a history of changes, and may explain why the code is doing something a certain way.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116872</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116764</id>
	<title>Not always true</title>
	<author>cecille</author>
	<datestamp>1258393500000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>Yes, spelling and grammar in comments are important for understanding, and proper spelling in variable names in particular makes it easier for developers after you to follow and track through code.  However, I disagree with the generalization that long comments always mean you don't know what you are doing.  Most of my code comments are 1-liners, but I always leave long comments for function headers so everyone is clear on what the inputs are.  I also leave larger comments for equations that aren't immediately obvious, ESPECIALLY if the equations are coming from spec documents.  A spec number, section number and explanation help developers FIND these things later and actually understand them.  Spec documents in particular can be thick and it's not always easy to see at a glance how things are supposed to work.  Plus, if there IS a mistake (let's face it, no one is perfect), it's way easier to track where something went wrong if you know what the start point is.</htmltext>
<tokenext>Yes , spelling and grammar in comments are important for understanding , and proper spelling in variable names in particular makes it easier for developers after you to follow and track through code .
However , I disagree with the generalization that long comments always mean you do n't know what you are doing .
Most of my code comments are 1-liners , but I always leave long comments for function headers so everyone is clear on what the inputs are .
I also leave larger comments for equations that are n't immediately obvious , ESPECIALLY if the equations are coming from spec documents .
A spec number , section number and explanation help developers FIND these things later and actually understand them .
Spec documents in particular can be thick and it 's not always easy to see at a glance how things are supposed to work .
Plus , if there IS a mistake ( let 's face it , no one is perfect ) , it 's way easier to track where something went wrong if you know what the start point is .</tokentext>
<sentencetext>Yes, spelling and grammar in comments are important for understanding, and proper spelling in variable names in particular makes it easier for developers after you to follow and track through code.
However, I disagree with the generalization that long comments always mean you don't know what you are doing.
Most of my code comments are 1-liners, but I always leave long comments for function headers so everyone is clear on what the inputs are.
I also leave larger comments for equations that aren't immediately obvious, ESPECIALLY if the equations are coming from spec documents.
A spec number, section number and explanation help developers FIND these things later and actually understand them.
Spec documents in particular can be thick and it's not always easy to see at a glance how things are supposed to work.
Plus, if there IS a mistake (let's face it, no one is perfect), it's way easier to track where something went wrong if you know what the start point is.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117098</id>
	<title>Re:Job Security</title>
	<author>dmgxmichael</author>
	<datestamp>1258394760000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Failure to comment doesn't secure your code - it just insures your code will be thrown away when the next guy comes in. It also increases the likelihood that your pissed off prior employer doesn't give you any references.</p><p>I'm currently digging through a nightmare code base. Not only are there no comments, but there's <b>NO INDENTING EITHER.</b> At all. I don't see how the guy who wrote it got as far as he did but. I take that back - he did occasionally comment, but only to mark the end of loops and functions which would be obvious if he would have indented his blasted code.</p><p>The decision has been made to patch what urgently needs to be patched in his code, then can it and start over from scratch. And I and my boss have already explained in detail to two calling in programmers exactly why it would be foolish to hire the moron.</p></htmltext>
<tokenext>Failure to comment does n't secure your code - it just insures your code will be thrown away when the next guy comes in .
It also increases the likelihood that your pissed off prior employer does n't give you any references.I 'm currently digging through a nightmare code base .
Not only are there no comments , but there 's NO INDENTING EITHER .
At all .
I do n't see how the guy who wrote it got as far as he did but .
I take that back - he did occasionally comment , but only to mark the end of loops and functions which would be obvious if he would have indented his blasted code.The decision has been made to patch what urgently needs to be patched in his code , then can it and start over from scratch .
And I and my boss have already explained in detail to two calling in programmers exactly why it would be foolish to hire the moron .</tokentext>
<sentencetext>Failure to comment doesn't secure your code - it just insures your code will be thrown away when the next guy comes in.
It also increases the likelihood that your pissed off prior employer doesn't give you any references.I'm currently digging through a nightmare code base.
Not only are there no comments, but there's NO INDENTING EITHER.
At all.
I don't see how the guy who wrote it got as far as he did but.
I take that back - he did occasionally comment, but only to mark the end of loops and functions which would be obvious if he would have indented his blasted code.The decision has been made to patch what urgently needs to be patched in his code, then can it and start over from scratch.
And I and my boss have already explained in detail to two calling in programmers exactly why it would be foolish to hire the moron.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116796</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30119782</id>
	<title>Comments?</title>
	<author>pak9rabid</author>
	<datestamp>1258402980000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>The code you have to deal with actually has comments in it?  That must be nice.  The only time I ever encounter comments at work when having to deal with someone else's code is when it says something along the lines of<nobr> <wbr></nobr>/* I'm really sorry about this... */</htmltext>
<tokenext>The code you have to deal with actually has comments in it ?
That must be nice .
The only time I ever encounter comments at work when having to deal with someone else 's code is when it says something along the lines of / * I 'm really sorry about this... * /</tokentext>
<sentencetext>The code you have to deal with actually has comments in it?
That must be nice.
The only time I ever encounter comments at work when having to deal with someone else's code is when it says something along the lines of /* I'm really sorry about this... */</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30126336</id>
	<title>My beautiful code snippet</title>
	<author>InfiniteLoopCounter</author>
	<datestamp>1258399020000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>public static publicstatic(int main) {<br>label:<br>long long long\_number = 0;<br>for (int inti=0; inti&gt;0; ++i) { };<br>long int integer = 0;int sky\_is\_green = sky\_is\_blue= 0;<br>if (long\_numer!=80) {<br>if ((long int) long\_number==integer &amp;&amp; sky\_is\_green!=~long\_number) printf ("hell");<br>if (!sky\_is\_blue) printc('o');<br>else print ("my god!");<br>printc(" "); }<br>else if (!sky\_is\_green!=sky\_is\_blue)<br>goto label;<br>else<br>printf("there");<br>printf("world!"); }</p><p><nobr> <wbr></nobr>/* This beautiful code snippet above outputs the phrase "hello world!" to the display. */</p></htmltext>
<tokenext>public static publicstatic ( int main ) { label : long long long \ _number = 0 ; for ( int inti = 0 ; inti &gt; 0 ; + + i ) { } ; long int integer = 0 ; int sky \ _is \ _green = sky \ _is \ _blue = 0 ; if ( long \ _numer ! = 80 ) { if ( ( long int ) long \ _number = = integer &amp;&amp; sky \ _is \ _green ! = ~ long \ _number ) printf ( " hell " ) ; if ( ! sky \ _is \ _blue ) printc ( 'o ' ) ; else print ( " my god !
" ) ; printc ( " " ) ; } else if ( ! sky \ _is \ _green ! = sky \ _is \ _blue ) goto label ; elseprintf ( " there " ) ; printf ( " world !
" ) ; } / * This beautiful code snippet above outputs the phrase " hello world !
" to the display .
* /</tokentext>
<sentencetext>public static publicstatic(int main) {label:long long long\_number = 0;for (int inti=0; inti&gt;0; ++i) { };long int integer = 0;int sky\_is\_green = sky\_is\_blue= 0;if (long\_numer!=80) {if ((long int) long\_number==integer &amp;&amp; sky\_is\_green!=~long\_number) printf ("hell");if (!sky\_is\_blue) printc('o');else print ("my god!
");printc(" "); }else if (!sky\_is\_green!=sky\_is\_blue)goto label;elseprintf("there");printf("world!
"); } /* This beautiful code snippet above outputs the phrase "hello world!
" to the display.
*/</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116760</id>
	<title>You must be joking.</title>
	<author>newdsfornerds</author>
	<datestamp>1258393500000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>You expect computer people to know the difference between "your" and "you're?" Hah!

Good luck with that. Most of the people I have worked with over ten years refuse to spell correctly or use proper grammar. If being literate was a requirement for employment, that could change.</htmltext>
<tokenext>You expect computer people to know the difference between " your " and " you 're ?
" Hah !
Good luck with that .
Most of the people I have worked with over ten years refuse to spell correctly or use proper grammar .
If being literate was a requirement for employment , that could change .</tokentext>
<sentencetext>You expect computer people to know the difference between "your" and "you're?
" Hah!
Good luck with that.
Most of the people I have worked with over ten years refuse to spell correctly or use proper grammar.
If being literate was a requirement for employment, that could change.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30127862</id>
	<title>Meta comments</title>
	<author>Anonymous</author>
	<datestamp>1258466340000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Which is why I prefer reading Meta comments over comments that tell what said code is doing.  I can tell what the code is doing just by reading it.  In any case a quick comment at the beginning is enough.  What really comes in handy later when fixing bugs or adding features is Meta comments.  These are the "Why" did I do it that way comments.  These comments explain why I'm using a certain structure, variable, etc.  They explain what I was thinking at the time.  Why did I do it a particular way.  That reasoning may or may not be wrong later, may be able to be improved, but it gives me a real reason to re-write said code or leave it alone.  i.e. It explains why if change this particular bit of code, I need to plan on changing a lot of other code as well.</p></htmltext>
<tokenext>Which is why I prefer reading Meta comments over comments that tell what said code is doing .
I can tell what the code is doing just by reading it .
In any case a quick comment at the beginning is enough .
What really comes in handy later when fixing bugs or adding features is Meta comments .
These are the " Why " did I do it that way comments .
These comments explain why I 'm using a certain structure , variable , etc .
They explain what I was thinking at the time .
Why did I do it a particular way .
That reasoning may or may not be wrong later , may be able to be improved , but it gives me a real reason to re-write said code or leave it alone .
i.e. It explains why if change this particular bit of code , I need to plan on changing a lot of other code as well .</tokentext>
<sentencetext>Which is why I prefer reading Meta comments over comments that tell what said code is doing.
I can tell what the code is doing just by reading it.
In any case a quick comment at the beginning is enough.
What really comes in handy later when fixing bugs or adding features is Meta comments.
These are the "Why" did I do it that way comments.
These comments explain why I'm using a certain structure, variable, etc.
They explain what I was thinking at the time.
Why did I do it a particular way.
That reasoning may or may not be wrong later, may be able to be improved, but it gives me a real reason to re-write said code or leave it alone.
i.e. It explains why if change this particular bit of code, I need to plan on changing a lot of other code as well.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121902</id>
	<title>Re:// teh code is obvius</title>
	<author>Anonymous</author>
	<datestamp>1258367580000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Rather a wimp than a ****ing idiot.</p></htmltext>
<tokenext>Rather a wimp than a * * * * ing idiot .</tokentext>
<sentencetext>Rather a wimp than a ****ing idiot.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116670</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30128108</id>
	<title>Python comments/docstrings need a lot more</title>
	<author>verdante</author>
	<datestamp>1258468680000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>In Python, long comments are necessary in any public-facing code.<br>
1) Due to the dynamic duck-typing, the docstring is the only place where you can explain to the world the exact structure and conditions of each parameter and the return value, especially if you are returning a dict that maps pairs of records to vectors.<br> <br>
2) The docstrings are where you put the doctests, which form an  executable mini-unit-test and mini-tutorial for every public API.  doctests also mean you have to write the code with few explicit dependencies (or spend most of the test lines mocking them out).<br> <br>
A 4-parameter public API function easily needs:<br> <br>
1 line (maybe 2) for description, followed by 1 blank line<br>
+4*2 lines for the<nobr> <wbr></nobr>:type: and<nobr> <wbr></nobr>:param: descriptions<br>
+2 lines for<nobr> <wbr></nobr>:rtype: and<nobr> <wbr></nobr>:return: descriptions<br>
+5 lines or more for the &gt;&gt;&gt; doctest lines<br>
&gt;=17 lines of comment per such function</htmltext>
<tokenext>In Python , long comments are necessary in any public-facing code .
1 ) Due to the dynamic duck-typing , the docstring is the only place where you can explain to the world the exact structure and conditions of each parameter and the return value , especially if you are returning a dict that maps pairs of records to vectors .
2 ) The docstrings are where you put the doctests , which form an executable mini-unit-test and mini-tutorial for every public API .
doctests also mean you have to write the code with few explicit dependencies ( or spend most of the test lines mocking them out ) .
A 4-parameter public API function easily needs : 1 line ( maybe 2 ) for description , followed by 1 blank line + 4 * 2 lines for the : type : and : param : descriptions + 2 lines for : rtype : and : return : descriptions + 5 lines or more for the &gt; &gt; &gt; doctest lines &gt; = 17 lines of comment per such function</tokentext>
<sentencetext>In Python, long comments are necessary in any public-facing code.
1) Due to the dynamic duck-typing, the docstring is the only place where you can explain to the world the exact structure and conditions of each parameter and the return value, especially if you are returning a dict that maps pairs of records to vectors.
2) The docstrings are where you put the doctests, which form an  executable mini-unit-test and mini-tutorial for every public API.
doctests also mean you have to write the code with few explicit dependencies (or spend most of the test lines mocking them out).
A 4-parameter public API function easily needs: 
1 line (maybe 2) for description, followed by 1 blank line
+4*2 lines for the :type: and :param: descriptions
+2 lines for :rtype: and :return: descriptions
+5 lines or more for the &gt;&gt;&gt; doctest lines
&gt;=17 lines of comment per such function</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118644</id>
	<title>Re:Yes, that's bad coding</title>
	<author>cppmonkey</author>
	<datestamp>1258399500000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Is it bad coding? Yes. Is this the worse coding? No. We've all been pressured to ship and all too often it sucks. But you commented the code indicating that you don't know why it works which helps your or the next person to come along to fix the problem. Points for actually commenting and saying you don't understand, shipping code you don't understand; not good. But the big question is did you go back and review the comments and try to fix the problem (ie understand your code)</p></htmltext>
<tokenext>Is it bad coding ?
Yes. Is this the worse coding ?
No. We 've all been pressured to ship and all too often it sucks .
But you commented the code indicating that you do n't know why it works which helps your or the next person to come along to fix the problem .
Points for actually commenting and saying you do n't understand , shipping code you do n't understand ; not good .
But the big question is did you go back and review the comments and try to fix the problem ( ie understand your code )</tokentext>
<sentencetext>Is it bad coding?
Yes. Is this the worse coding?
No. We've all been pressured to ship and all too often it sucks.
But you commented the code indicating that you don't know why it works which helps your or the next person to come along to fix the problem.
Points for actually commenting and saying you don't understand, shipping code you don't understand; not good.
But the big question is did you go back and review the comments and try to fix the problem (ie understand your code)</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116852</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121294</id>
	<title>Some documentation guidelines</title>
	<author>Anonymous</author>
	<datestamp>1258365240000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>I just recently wrote some API documentation guidelines for our developers. You might want to <a href="http://dev.vaadin.com/browser/doc/trunk/guidelines/api-documentation.pdf" title="vaadin.com" rel="nofollow">check them out</a> [vaadin.com] (click "downloading" link) if you are interested.</p><p>Feel free to comment, I'm sure some points in the guidelines may be questionable. There's also a handy <a href="http://dev.vaadin.com/browser/doc/trunk/guidelines/api-documentation-card.pdf" title="vaadin.com" rel="nofollow">reference card</a> [vaadin.com] (click "downloading" link).</p></htmltext>
<tokenext>I just recently wrote some API documentation guidelines for our developers .
You might want to check them out [ vaadin.com ] ( click " downloading " link ) if you are interested.Feel free to comment , I 'm sure some points in the guidelines may be questionable .
There 's also a handy reference card [ vaadin.com ] ( click " downloading " link ) .</tokentext>
<sentencetext>I just recently wrote some API documentation guidelines for our developers.
You might want to check them out [vaadin.com] (click "downloading" link) if you are interested.Feel free to comment, I'm sure some points in the guidelines may be questionable.
There's also a handy reference card [vaadin.com] (click "downloading" link).</sentencetext>
</comment>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_49</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116558
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116652
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116726
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117026
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118668
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_40</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116670
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121902
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_25</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116872
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117692
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_6</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116558
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116652
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116726
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117028
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120992
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_30</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116694
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117930
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_64</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116868
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117648
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30133684
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_1</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116734
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117080
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_55</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116734
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30119428
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30133570
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_78</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117196
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118070
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_3</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116670
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120880
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_83</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117090
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121092
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30131254
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_54</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116558
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116652
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116852
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118644
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_17</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116680
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116970
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117362
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_19</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116872
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30133548
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_22</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117144
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30123956
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_47</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116778
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118368
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30133606
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_18</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116872
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117572
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_12</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116778
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117442
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_4</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116778
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30125534
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_77</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116558
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116652
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116726
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117026
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30124120
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_80</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116610
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118688
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_53</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116558
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116652
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116726
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120210
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30124238
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_76</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116672
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121178
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_39</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116872
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30123504
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_67</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117144
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118764
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_70</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116716
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117122
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_44</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116734
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30124816
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_29</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116872
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117720
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_20</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116670
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117056
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_11</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116868
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30128270
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_34</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118918
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30202712
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_10</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116868
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121246
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_68</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116748
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30127916
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_41</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116778
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117484
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_59</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116868
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121264
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_7</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116868
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117422
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_75</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116868
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117648
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121434
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_58</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116694
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116916
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_65</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117090
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117566
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_26</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117090
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120184
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_42</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116796
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117098
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30119376
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_33</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116872
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117246
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_16</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116872
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30123716
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_8</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116666
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117586
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_32</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116558
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116652
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116726
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117026
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30166536
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_23</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116734
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30125378
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_84</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116680
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116970
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117944
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_57</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116558
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116652
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116726
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117028
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121306
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_60</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116610
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120832
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_5</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116558
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116652
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116726
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117134
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30123032
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_62</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116610
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120924
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_48</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117090
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121316
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_81</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116558
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116652
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116726
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117028
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30133250
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_24</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116558
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116652
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116726
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117026
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30133196
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_52</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116872
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30119230
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_15</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117090
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30122932
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_38</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117366
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118426
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_31</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117090
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30128432
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_14</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116868
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117648
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30126244
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_45</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116872
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121666
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_0</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116610
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120156
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_79</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116672
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117344
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_21</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116716
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118240
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_2</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116872
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120294
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_82</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116558
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116652
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116852
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30133288
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_73</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116558
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116652
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116726
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117028
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121028
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_69</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116734
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30126196
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_72</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116868
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30126682
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_51</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116886
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118176
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_46</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116558
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116652
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116726
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117028
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30119754
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_74</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116796
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117098
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118182
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_37</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117366
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30136066
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_50</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116716
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30122986
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_13</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116558
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116652
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116892
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_36</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116558
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116652
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116726
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117028
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120320
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_27</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116734
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30125040
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_43</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116872
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118418
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_9</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118256
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121396
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_66</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116680
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116970
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117654
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_71</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117812
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120258
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_85</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116734
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120712
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_28</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116868
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30125652
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_56</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116716
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118448
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_61</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116558
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116652
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116724
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118850
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_35</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116868
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118868
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_16_1626218_63</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116872
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30125760
</commentlist>
</thread>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_16_1626218.15</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116672
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117344
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121178
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_16_1626218.12</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116868
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117648
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30126244
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30133684
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121434
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121264
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117422
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30125652
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121246
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118868
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30126682
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30128270
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_16_1626218.25</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116610
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120156
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118688
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120832
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120924
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_16_1626218.26</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116760
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_16_1626218.20</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116716
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118240
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30122986
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117122
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118448
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_16_1626218.17</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116778
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117484
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118368
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30133606
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117442
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30125534
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_16_1626218.35</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116886
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118176
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_16_1626218.32</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117196
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118070
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_16_1626218.6</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30123574
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_16_1626218.9</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116694
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117930
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116916
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_16_1626218.3</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116748
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30127916
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_16_1626218.1</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117152
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_16_1626218.11</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117088
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_16_1626218.14</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116680
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116970
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117654
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117362
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117944
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_16_1626218.28</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116872
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121666
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30125760
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117692
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117246
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118418
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30119230
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117572
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30133548
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30123504
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120294
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117720
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30123716
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_16_1626218.27</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116776
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_16_1626218.21</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121952
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_16_1626218.31</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116734
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30119428
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30133570
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30126196
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117080
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30124816
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120712
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30125040
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30125378
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_16_1626218.22</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117576
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_16_1626218.19</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116670
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120880
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121902
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117056
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_16_1626218.8</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116836
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_16_1626218.16</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30149212
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_16_1626218.0</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117366
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30136066
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118426
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_16_1626218.34</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117014
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_16_1626218.29</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116666
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117586
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_16_1626218.5</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116796
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117098
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30119376
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118182
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_16_1626218.13</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116558
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116652
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116724
---http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118850
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116726
---http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117134
----http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30123032
---http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117028
----http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121028
----http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121306
----http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30133250
----http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30119754
----http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120992
----http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120320
---http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117026
----http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118668
----http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30133196
----http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30166536
----http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30124120
---http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120210
----http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30124238
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116852
---http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30133288
---http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118644
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116892
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_16_1626218.10</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118918
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30202712
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_16_1626218.23</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117090
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117566
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120184
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121092
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30131254
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121316
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30128432
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30122932
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_16_1626218.30</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118256
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30121396
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_16_1626218.24</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116978
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_16_1626218.33</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117812
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120258
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_16_1626218.36</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118498
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_16_1626218.4</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30120170
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_16_1626218.2</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117276
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_16_1626218.18</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30116874
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_16_1626218.7</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30117144
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30118764
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_16_1626218.30123956
</commentlist>
</conversation>
