<article>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#article09_05_31_1423203</id>
	<title>Comparing the Size, Speed, and Dependability of Programming Languages</title>
	<author>Soulskill</author>
	<datestamp>1243781040000</datestamp>
	<htmltext>In this blog post, the author plots the results of 19 different benchmark tests across 72 programming languages to <a href="http://gmarceau.qc.ca/blog/2009/05/speed-size-and-dependability-of.html">create a quantitative comparison between them</a>. The resulting visualizations give insight into how the languages perform across a variety of tasks, and also how some some languages perform in relation to others.
<i>"If you drew the benchmark results on an XY chart you could name the four corners. The fast but verbose languages would cluster at the top left. Let's call them system languages. The elegantly concise but sluggish languages would cluster at the bottom right. Let's call them script languages. On the top right you would find the obsolete languages. That is, languages which have since been outclassed by newer languages, unless they offer some quirky attraction that is not captured by the data here. And finally, in the bottom left corner you would find probably nothing, since this is the space of the ideal language, the one which is at the same time fast and short and a joy to use."</i></htmltext>
<tokenext>In this blog post , the author plots the results of 19 different benchmark tests across 72 programming languages to create a quantitative comparison between them .
The resulting visualizations give insight into how the languages perform across a variety of tasks , and also how some some languages perform in relation to others .
" If you drew the benchmark results on an XY chart you could name the four corners .
The fast but verbose languages would cluster at the top left .
Let 's call them system languages .
The elegantly concise but sluggish languages would cluster at the bottom right .
Let 's call them script languages .
On the top right you would find the obsolete languages .
That is , languages which have since been outclassed by newer languages , unless they offer some quirky attraction that is not captured by the data here .
And finally , in the bottom left corner you would find probably nothing , since this is the space of the ideal language , the one which is at the same time fast and short and a joy to use .
"</tokentext>
<sentencetext>In this blog post, the author plots the results of 19 different benchmark tests across 72 programming languages to create a quantitative comparison between them.
The resulting visualizations give insight into how the languages perform across a variety of tasks, and also how some some languages perform in relation to others.
"If you drew the benchmark results on an XY chart you could name the four corners.
The fast but verbose languages would cluster at the top left.
Let's call them system languages.
The elegantly concise but sluggish languages would cluster at the bottom right.
Let's call them script languages.
On the top right you would find the obsolete languages.
That is, languages which have since been outclassed by newer languages, unless they offer some quirky attraction that is not captured by the data here.
And finally, in the bottom left corner you would find probably nothing, since this is the space of the ideal language, the one which is at the same time fast and short and a joy to use.
"</sentencetext>
</article>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28163435</id>
	<title>Oops.</title>
	<author>Anonymous</author>
	<datestamp>1243783980000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>It's funny that you made an error in the simplest one....</p></htmltext>
<tokenext>It 's funny that you made an error in the simplest one... .</tokentext>
<sentencetext>It's funny that you made an error in the simplest one....</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28165315</id>
	<title>Re:What kind of verbosity?</title>
	<author>Anonymous</author>
	<datestamp>1243848540000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>You managed to code a bug in the second line. i'll vote for a language where such bugs are caught by preprocessor/compiler/lint , rather than at runtime. Even if it comes at the cost of greater verbosity. No programming language will ever save you from expressing your intent clearly.</p></htmltext>
<tokenext>You managed to code a bug in the second line .
i 'll vote for a language where such bugs are caught by preprocessor/compiler/lint , rather than at runtime .
Even if it comes at the cost of greater verbosity .
No programming language will ever save you from expressing your intent clearly .</tokentext>
<sentencetext>You managed to code a bug in the second line.
i'll vote for a language where such bugs are caught by preprocessor/compiler/lint , rather than at runtime.
Even if it comes at the cost of greater verbosity.
No programming language will ever save you from expressing your intent clearly.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160805</id>
	<title>Seems odd about Smalltalk</title>
	<author>WeirdJohn</author>
	<datestamp>1243761420000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>It seems odd to me that the Smalltalk implementations are all so far to the right and so far up, especially the latter.  Smalltalk is usually considered to have a very high amount of bang per LOC, at least 15 times more than C++.  If they are considering superclasses in the code size count are they considering libc for gcc, or the entire dotNet libraries for C#?</p><p>I have to wonder how good the smalltalkers were that implemented the benchmarks.  Until you get your head around it, smalltalk code is bloated.  Then as you learn to think the right way your code shrinks to a beautifully expressive minimalism.</p></htmltext>
<tokenext>It seems odd to me that the Smalltalk implementations are all so far to the right and so far up , especially the latter .
Smalltalk is usually considered to have a very high amount of bang per LOC , at least 15 times more than C + + .
If they are considering superclasses in the code size count are they considering libc for gcc , or the entire dotNet libraries for C # ? I have to wonder how good the smalltalkers were that implemented the benchmarks .
Until you get your head around it , smalltalk code is bloated .
Then as you learn to think the right way your code shrinks to a beautifully expressive minimalism .</tokentext>
<sentencetext>It seems odd to me that the Smalltalk implementations are all so far to the right and so far up, especially the latter.
Smalltalk is usually considered to have a very high amount of bang per LOC, at least 15 times more than C++.
If they are considering superclasses in the code size count are they considering libc for gcc, or the entire dotNet libraries for C#?I have to wonder how good the smalltalkers were that implemented the benchmarks.
Until you get your head around it, smalltalk code is bloated.
Then as you learn to think the right way your code shrinks to a beautifully expressive minimalism.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158969</id>
	<title>Re:Ruby</title>
	<author>Foofoobar</author>
	<datestamp>1243791060000</datestamp>
	<modclass>Troll</modclass>
	<modscore>1</modscore>
	<htmltext><blockquote><div><p>Why can't they make a language, or extend a language like Ruby, such that one can program it as a scripting language, but then add verbosity optionally</p></div></blockquote><p>

They did. It's called PHP. Notice how much better it scales in that benchmark.</p></div>
	</htmltext>
<tokenext>Why ca n't they make a language , or extend a language like Ruby , such that one can program it as a scripting language , but then add verbosity optionally They did .
It 's called PHP .
Notice how much better it scales in that benchmark .</tokentext>
<sentencetext>Why can't they make a language, or extend a language like Ruby, such that one can program it as a scripting language, but then add verbosity optionally

They did.
It's called PHP.
Notice how much better it scales in that benchmark.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158689</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28166463</id>
	<title>Re:What kind of verbosity?</title>
	<author>Phreakiture</author>
	<datestamp>1243863120000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I believe you have a typo . . . Shouldn't your first example say "print item" rather than "print list"?</p><p>Now, how about this:</p><p>
<tt>
print join ("\n", @list);
</tt>

</p><p>Perl, of course.  It's very clear and meaningful, and very concise, all at once.  It also eschews all of the visual cruft of having to build a loop when one is really not needed.</p><p>Perl gets a bad rap for some of the serious junk that is written in it, but I think that an example such as the one I just gave demonstrates that there is great power there, and that it can work well if coupled with an appropriate level of responsibility.</p></htmltext>
<tokenext>I believe you have a typo .
. .
Should n't your first example say " print item " rather than " print list " ? Now , how about this : print join ( " \ n " , @ list ) ; Perl , of course .
It 's very clear and meaningful , and very concise , all at once .
It also eschews all of the visual cruft of having to build a loop when one is really not needed.Perl gets a bad rap for some of the serious junk that is written in it , but I think that an example such as the one I just gave demonstrates that there is great power there , and that it can work well if coupled with an appropriate level of responsibility .</tokentext>
<sentencetext>I believe you have a typo .
. .
Shouldn't your first example say "print item" rather than "print list"?Now, how about this:

print join ("\n", @list);


Perl, of course.
It's very clear and meaningful, and very concise, all at once.
It also eschews all of the visual cruft of having to build a loop when one is really not needed.Perl gets a bad rap for some of the serious junk that is written in it, but I think that an example such as the one I just gave demonstrates that there is great power there, and that it can work well if coupled with an appropriate level of responsibility.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158405</id>
	<title>Where are the real lanaguages???</title>
	<author>jackb\_guppy</author>
	<datestamp>1243786560000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>4</modscore>
	<htmltext><p>Where Cobol and RPG, the languages that run business?</p></htmltext>
<tokenext>Where Cobol and RPG , the languages that run business ?</tokentext>
<sentencetext>Where Cobol and RPG, the languages that run business?</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28164923</id>
	<title>Mr. T's programming language</title>
	<author>Tablizer</author>
	<datestamp>1243798920000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>nuf sed</p></htmltext>
<tokenext>nuf sed</tokentext>
<sentencetext>nuf sed</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158335</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160159</id>
	<title>A language does not have performance</title>
	<author>Anonymous</author>
	<datestamp>1243800120000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>3</modscore>
	<htmltext><p>Performance is created by the compiler, not the language. A C program compiled with a shitty compiler is going to run slower than a Ruby one in a good VM, even though C is running native on the CPU. For that matter, what if I take the C code and compile it with the CLR as a VM target?</p><p>I wish people would stop trying to compare languages by performance, it does not make any sense. The only language it makes any sense for at all is assembler.</p></htmltext>
<tokenext>Performance is created by the compiler , not the language .
A C program compiled with a shitty compiler is going to run slower than a Ruby one in a good VM , even though C is running native on the CPU .
For that matter , what if I take the C code and compile it with the CLR as a VM target ? I wish people would stop trying to compare languages by performance , it does not make any sense .
The only language it makes any sense for at all is assembler .</tokentext>
<sentencetext>Performance is created by the compiler, not the language.
A C program compiled with a shitty compiler is going to run slower than a Ruby one in a good VM, even though C is running native on the CPU.
For that matter, what if I take the C code and compile it with the CLR as a VM target?I wish people would stop trying to compare languages by performance, it does not make any sense.
The only language it makes any sense for at all is assembler.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28161021</id>
	<title>Re:Pet peeve</title>
	<author>glwtta</author>
	<datestamp>1243762860000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><i>Programming languages don't have attributes like size and speed</i>
<br> <br>
Well, not speed (that's why different compilers are profiled, btw), but certainly <i>size</i>: we're talking about code size here, not memory size (or binary size).</htmltext>
<tokenext>Programming languages do n't have attributes like size and speed Well , not speed ( that 's why different compilers are profiled , btw ) , but certainly size : we 're talking about code size here , not memory size ( or binary size ) .</tokentext>
<sentencetext>Programming languages don't have attributes like size and speed
 
Well, not speed (that's why different compilers are profiled, btw), but certainly size: we're talking about code size here, not memory size (or binary size).</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158375</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159809</id>
	<title>Re:The perfect language exists, you ignorant clod!</title>
	<author>Anonymous</author>
	<datestamp>1243797360000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>That might just be the funniest thing I have ever read on slashdot.</p></htmltext>
<tokenext>That might just be the funniest thing I have ever read on slashdot .</tokentext>
<sentencetext>That might just be the funniest thing I have ever read on slashdot.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158335</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158795</id>
	<title>C vs C++</title>
	<author>masmullin</author>
	<datestamp>1243789800000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext>C++ got a better score.  Am I reading this right?</htmltext>
<tokenext>C + + got a better score .
Am I reading this right ?</tokentext>
<sentencetext>C++ got a better score.
Am I reading this right?</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158941</id>
	<title>Re:Scala</title>
	<author>DetpackJump</author>
	<datestamp>1243790820000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>3</modscore>
	<htmltext>I was curious about that too, so I'm looking at the code. The Java implementation seems to be importing a non-java library, jgmplib. Anyone know what is going on here?</htmltext>
<tokenext>I was curious about that too , so I 'm looking at the code .
The Java implementation seems to be importing a non-java library , jgmplib .
Anyone know what is going on here ?</tokentext>
<sentencetext>I was curious about that too, so I'm looking at the code.
The Java implementation seems to be importing a non-java library, jgmplib.
Anyone know what is going on here?</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158307</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160987</id>
	<title>Re:Scala</title>
	<author>Anonymous</author>
	<datestamp>1243762680000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>There are 3 things that jump to mind about this.</p><p>The Scala compiler produces code which is difficult for the JVM/JIT to improve.  Something like lots of short lived objects or just crummy algorithms could do it.  I suspect it's the short lived objects since it's a functional language, and it would be easy for a functional language compiler to preserve not recognize when in place changes to an object are ok, rather than creating a new object.</p><p>Another thing to think about is that the JVM/JIT was built with the Java language in mind.  Java doesn't behave like a functional language in most places.  Garbage Collection and it's handling of strings are exceptions to this.  JVM/JIT does expect certain types of byte code patterns to be thrown at it.</p><p>There's also the actual source implementations of the benchmarks to consider.  At that level there are way too many things to consider that may play into the differences.</p></htmltext>
<tokenext>There are 3 things that jump to mind about this.The Scala compiler produces code which is difficult for the JVM/JIT to improve .
Something like lots of short lived objects or just crummy algorithms could do it .
I suspect it 's the short lived objects since it 's a functional language , and it would be easy for a functional language compiler to preserve not recognize when in place changes to an object are ok , rather than creating a new object.Another thing to think about is that the JVM/JIT was built with the Java language in mind .
Java does n't behave like a functional language in most places .
Garbage Collection and it 's handling of strings are exceptions to this .
JVM/JIT does expect certain types of byte code patterns to be thrown at it.There 's also the actual source implementations of the benchmarks to consider .
At that level there are way too many things to consider that may play into the differences .</tokentext>
<sentencetext>There are 3 things that jump to mind about this.The Scala compiler produces code which is difficult for the JVM/JIT to improve.
Something like lots of short lived objects or just crummy algorithms could do it.
I suspect it's the short lived objects since it's a functional language, and it would be easy for a functional language compiler to preserve not recognize when in place changes to an object are ok, rather than creating a new object.Another thing to think about is that the JVM/JIT was built with the Java language in mind.
Java doesn't behave like a functional language in most places.
Garbage Collection and it's handling of strings are exceptions to this.
JVM/JIT does expect certain types of byte code patterns to be thrown at it.There's also the actual source implementations of the benchmarks to consider.
At that level there are way too many things to consider that may play into the differences.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158307</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28161307</id>
	<title>Re:Forth, the RPN notational programming language</title>
	<author>Anonymous</author>
	<datestamp>1243765800000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Forth you like if honk</p></htmltext>
<tokenext>Forth you like if honk</tokentext>
<sentencetext>Forth you like if honk</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158377</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28162143</id>
	<title>Re:Forth, the RPN notational programming language</title>
	<author>Kuciwalker</author>
	<datestamp>1243773240000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>Forth is ONLY really useful as an embedded language.  The only reason for its existence is that it is even easier to implement (and has a smaller runtime) than C.</htmltext>
<tokenext>Forth is ONLY really useful as an embedded language .
The only reason for its existence is that it is even easier to implement ( and has a smaller runtime ) than C .</tokentext>
<sentencetext>Forth is ONLY really useful as an embedded language.
The only reason for its existence is that it is even easier to implement (and has a smaller runtime) than C.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159419</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28165019</id>
	<title>Re:This is totaly stupid</title>
	<author>Anonymous</author>
	<datestamp>1243886760000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Hee-hee, so basically wrong, that I can see and I'm not even a programmer.</p><p><div class="quote"><p>The one metric that has real meaning is programmer enjoyment.  Do you prefer terseness over verbosity or something in between.  Does this languages flow amke you truly appreciate working with it.</p></div><p>Example: Ruby. I hear it has lots of enjoyment. Sometimes you shouldn't implement a program in Ruby. Exhibit A: Twitter.</p><p><div class="quote"><p>The only other real metric that has any true meaning is again the talent of the compiler / interpreter author.</p></div><p>No, the language imposes restrictions that make certain operations easier or harder to perform. Sometimes the language makes some operations impossible to do.</p><p>For example, consider machine code, the lowest level programming language. Theoretically, you could virtualize any platform. In practice, a clean platform like POWER was built for virtualization, while Intel x86 made do with hacks such as VMWare's trap and patch technique until the recent virtualization fad forced AMD and Intel to add extensions for it.</p></div>
	</htmltext>
<tokenext>Hee-hee , so basically wrong , that I can see and I 'm not even a programmer.The one metric that has real meaning is programmer enjoyment .
Do you prefer terseness over verbosity or something in between .
Does this languages flow amke you truly appreciate working with it.Example : Ruby .
I hear it has lots of enjoyment .
Sometimes you should n't implement a program in Ruby .
Exhibit A : Twitter.The only other real metric that has any true meaning is again the talent of the compiler / interpreter author.No , the language imposes restrictions that make certain operations easier or harder to perform .
Sometimes the language makes some operations impossible to do.For example , consider machine code , the lowest level programming language .
Theoretically , you could virtualize any platform .
In practice , a clean platform like POWER was built for virtualization , while Intel x86 made do with hacks such as VMWare 's trap and patch technique until the recent virtualization fad forced AMD and Intel to add extensions for it .</tokentext>
<sentencetext>Hee-hee, so basically wrong, that I can see and I'm not even a programmer.The one metric that has real meaning is programmer enjoyment.
Do you prefer terseness over verbosity or something in between.
Does this languages flow amke you truly appreciate working with it.Example: Ruby.
I hear it has lots of enjoyment.
Sometimes you shouldn't implement a program in Ruby.
Exhibit A: Twitter.The only other real metric that has any true meaning is again the talent of the compiler / interpreter author.No, the language imposes restrictions that make certain operations easier or harder to perform.
Sometimes the language makes some operations impossible to do.For example, consider machine code, the lowest level programming language.
Theoretically, you could virtualize any platform.
In practice, a clean platform like POWER was built for virtualization, while Intel x86 made do with hacks such as VMWare's trap and patch technique until the recent virtualization fad forced AMD and Intel to add extensions for it.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158899</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28164933</id>
	<title>Re:some random observations</title>
	<author>Anonymous</author>
	<datestamp>1243799100000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p><div class="quote"><p>The biggest surprise for me was the high performance of some of the implementations of functional programming languages, even in cases where the particular languages aren't generally known for being implementable in a very efficient way. Two of the best-performing languages are stalin (an implementation of scheme/lisp) and mlton (an implementation of ml).</p></div><p>If you RTFA, you would also notice that Stalin didn't have enough benchmarks ported to it to derive meaningful results.</p></div>
	</htmltext>
<tokenext>The biggest surprise for me was the high performance of some of the implementations of functional programming languages , even in cases where the particular languages are n't generally known for being implementable in a very efficient way .
Two of the best-performing languages are stalin ( an implementation of scheme/lisp ) and mlton ( an implementation of ml ) .If you RTFA , you would also notice that Stalin did n't have enough benchmarks ported to it to derive meaningful results .</tokentext>
<sentencetext>The biggest surprise for me was the high performance of some of the implementations of functional programming languages, even in cases where the particular languages aren't generally known for being implementable in a very efficient way.
Two of the best-performing languages are stalin (an implementation of scheme/lisp) and mlton (an implementation of ml).If you RTFA, you would also notice that Stalin didn't have enough benchmarks ported to it to derive meaningful results.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158809</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28165349</id>
	<title>Re:Ocaml</title>
	<author>TheTurtlesMoves</author>
	<datestamp>1243849020000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>A big problem with higher level languages is tools. They give awful error messages and often you don't even have a line number. As an example consider scheme. Its the error in the way the macro was called or the macro itself? Now consider that often standard language constructs are often implemented with macros we now need to consider a macro of a macro of a macro. Now try to understand that error message.....</htmltext>
<tokenext>A big problem with higher level languages is tools .
They give awful error messages and often you do n't even have a line number .
As an example consider scheme .
Its the error in the way the macro was called or the macro itself ?
Now consider that often standard language constructs are often implemented with macros we now need to consider a macro of a macro of a macro .
Now try to understand that error message.... .</tokentext>
<sentencetext>A big problem with higher level languages is tools.
They give awful error messages and often you don't even have a line number.
As an example consider scheme.
Its the error in the way the macro was called or the macro itself?
Now consider that often standard language constructs are often implemented with macros we now need to consider a macro of a macro of a macro.
Now try to understand that error message.....</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158575</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159161</id>
	<title>gnat</title>
	<author>Anonymous</author>
	<datestamp>1243792680000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>that's where</p></htmltext>
<tokenext>that 's where</tokentext>
<sentencetext>that's where</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158755</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158871</id>
	<title>Re:Ruby</title>
	<author>Anonymous</author>
	<datestamp>1243790220000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext>Peter Griffin: <p><div class="quote"><p>When I'm through with our schools our students will be so smart they will be able to program their VCRs without spilling piping hot gravy all over myself.</p></div><p>RiotXIX:</p><p><div class="quote"><p>Then why the fuck is the Ruby community hyping it so much, and drawing nieve young developers in to a trap?<br> <i>(...)</i> <br>
It's my hope that if <b>I</b> stick with Ruby<nobr> <wbr></nobr>...</p></div><p>Heh, sucker.</p></div>
	</htmltext>
<tokenext>Peter Griffin : When I 'm through with our schools our students will be so smart they will be able to program their VCRs without spilling piping hot gravy all over myself.RiotXIX : Then why the fuck is the Ruby community hyping it so much , and drawing nieve young developers in to a trap ?
( ... ) It 's my hope that if I stick with Ruby ...Heh , sucker .</tokentext>
<sentencetext>Peter Griffin: When I'm through with our schools our students will be so smart they will be able to program their VCRs without spilling piping hot gravy all over myself.RiotXIX:Then why the fuck is the Ruby community hyping it so much, and drawing nieve young developers in to a trap?
(...) 
It's my hope that if I stick with Ruby ...Heh, sucker.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158689</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160997</id>
	<title>Re:Ruby</title>
	<author>Anonymous</author>
	<datestamp>1243762740000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Considering it only takes a day or two to learn Python, it really wouldn't kill you either way.</p></htmltext>
<tokenext>Considering it only takes a day or two to learn Python , it really would n't kill you either way .</tokentext>
<sentencetext>Considering it only takes a day or two to learn Python, it really wouldn't kill you either way.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158689</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160675</id>
	<title>Re:This is totaly stupid</title>
	<author>Kjella</author>
	<datestamp>1243760520000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>3</modscore>
	<htmltext><p>I don't think that's the primary scale. I think my primary scale is:</p><p>What level of detail control is the programmer required to and permitted to have?<br>How easy is it for a developer to shoot himself (or others) in the foot?<br>How often must the developer work around poor or missing language features?</p><p>For example, there's no lower level than assembly but it has no high-level features. Java is high level but has no low-level memory and byte manipulation to speak of. I prefer C++/Qt, I have all the practical high-level functions for the quick gains, yet I can down dive to detailed C/C++ management.</p><p>In terms of "how easy is it to shoot himself in the foot?" I think C/C++ could do much better. Doing all sorts of pointer manipulation is error prone and zero-terminated char arrays are the thing of the devil. And while C++ has exceptions I've never seen them applied consistantly and well like in Java.</p><p>Finally, I think there should only be the need for ONE standard library, not a five library mashup that's kinda standard. Everything else should be modules usually building on top of that library. Java, C# has done it - I emulate it with Qt in C++ because I think STL/boost/whatever is not very good.</p></htmltext>
<tokenext>I do n't think that 's the primary scale .
I think my primary scale is : What level of detail control is the programmer required to and permitted to have ? How easy is it for a developer to shoot himself ( or others ) in the foot ? How often must the developer work around poor or missing language features ? For example , there 's no lower level than assembly but it has no high-level features .
Java is high level but has no low-level memory and byte manipulation to speak of .
I prefer C + + /Qt , I have all the practical high-level functions for the quick gains , yet I can down dive to detailed C/C + + management.In terms of " how easy is it to shoot himself in the foot ?
" I think C/C + + could do much better .
Doing all sorts of pointer manipulation is error prone and zero-terminated char arrays are the thing of the devil .
And while C + + has exceptions I 've never seen them applied consistantly and well like in Java.Finally , I think there should only be the need for ONE standard library , not a five library mashup that 's kinda standard .
Everything else should be modules usually building on top of that library .
Java , C # has done it - I emulate it with Qt in C + + because I think STL/boost/whatever is not very good .</tokentext>
<sentencetext>I don't think that's the primary scale.
I think my primary scale is:What level of detail control is the programmer required to and permitted to have?How easy is it for a developer to shoot himself (or others) in the foot?How often must the developer work around poor or missing language features?For example, there's no lower level than assembly but it has no high-level features.
Java is high level but has no low-level memory and byte manipulation to speak of.
I prefer C++/Qt, I have all the practical high-level functions for the quick gains, yet I can down dive to detailed C/C++ management.In terms of "how easy is it to shoot himself in the foot?
" I think C/C++ could do much better.
Doing all sorts of pointer manipulation is error prone and zero-terminated char arrays are the thing of the devil.
And while C++ has exceptions I've never seen them applied consistantly and well like in Java.Finally, I think there should only be the need for ONE standard library, not a five library mashup that's kinda standard.
Everything else should be modules usually building on top of that library.
Java, C# has done it - I emulate it with Qt in C++ because I think STL/boost/whatever is not very good.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158899</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28163465</id>
	<title>Re:Ruby</title>
	<author>thechao</author>
	<datestamp>1243784340000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>You're desire is for a language that supports "gradual typing"; read about it here: www.cs.colorado.edu/~siek/pubs/pubs/2006/siek06:\_gradual.pdf</p></htmltext>
<tokenext>You 're desire is for a language that supports " gradual typing " ; read about it here : www.cs.colorado.edu/ ~ siek/pubs/pubs/2006/siek06 : \ _gradual.pdf</tokentext>
<sentencetext>You're desire is for a language that supports "gradual typing"; read about it here: www.cs.colorado.edu/~siek/pubs/pubs/2006/siek06:\_gradual.pdf</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158689</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28172211</id>
	<title>Re:Ocaml</title>
	<author>naasking</author>
	<datestamp>1243888560000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>By saying they "don't fit your brain", you are implying that a programmer's brain is somehow naturally wired for programming. This is simply not true. We learn math, logic, and programming, and you could just as easily learn functional programming, and then your brain would be wired for it too. And you'd be better off IMO, because you would unlearn a lot of bad habits people pick up from imperative languages.</p></htmltext>
<tokenext>By saying they " do n't fit your brain " , you are implying that a programmer 's brain is somehow naturally wired for programming .
This is simply not true .
We learn math , logic , and programming , and you could just as easily learn functional programming , and then your brain would be wired for it too .
And you 'd be better off IMO , because you would unlearn a lot of bad habits people pick up from imperative languages .</tokentext>
<sentencetext>By saying they "don't fit your brain", you are implying that a programmer's brain is somehow naturally wired for programming.
This is simply not true.
We learn math, logic, and programming, and you could just as easily learn functional programming, and then your brain would be wired for it too.
And you'd be better off IMO, because you would unlearn a lot of bad habits people pick up from imperative languages.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158731</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159217</id>
	<title>Re:The perfect language exists, you ignorant clod!</title>
	<author>Anonymous</author>
	<datestamp>1243793160000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>eat my shit, bro</p></htmltext>
<tokenext>eat my shit , bro</tokentext>
<sentencetext>eat my shit, bro</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158335</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28170619</id>
	<title>Re:What kind of verbosity?</title>
	<author>Anonymous</author>
	<datestamp>1243882620000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Umm, assuming that your second example is supposed to be Java, I don't think that you even write decent Java code.  I would write that loop as<br>
&nbsp; &nbsp; &nbsp; &nbsp; for (Object obj : list) {<br>
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; System.out.println(obj)<br>
&nbsp; &nbsp; &nbsp; &nbsp; }</p><p>This is ALMOST as compact as the first (Python?) example.  It just has some Object typecasting and braces that add very mild verbosity.  The braces are bad: Java should have followed Pythons excellent lead and eliminated them (as long as tab char indenting is mandated to specify blocks; not spaces, spaces chars are evil for indenting, but thats another battle...).</p><p>This brings up another point: I could write that Java in a one liner as<br>
&nbsp; &nbsp; &nbsp; for (Object obj : list) System.out.println(obj)<br>if I want to.</p><p>So how much verbosity is intrinsic to the language, and how much is just due to the style preference of the implementing programmer?</p></htmltext>
<tokenext>Umm , assuming that your second example is supposed to be Java , I do n't think that you even write decent Java code .
I would write that loop as         for ( Object obj : list ) {               System.out.println ( obj )         } This is ALMOST as compact as the first ( Python ?
) example .
It just has some Object typecasting and braces that add very mild verbosity .
The braces are bad : Java should have followed Pythons excellent lead and eliminated them ( as long as tab char indenting is mandated to specify blocks ; not spaces , spaces chars are evil for indenting , but thats another battle... ) .This brings up another point : I could write that Java in a one liner as       for ( Object obj : list ) System.out.println ( obj ) if I want to.So how much verbosity is intrinsic to the language , and how much is just due to the style preference of the implementing programmer ?</tokentext>
<sentencetext>Umm, assuming that your second example is supposed to be Java, I don't think that you even write decent Java code.
I would write that loop as
        for (Object obj : list) {
              System.out.println(obj)
        }This is ALMOST as compact as the first (Python?
) example.
It just has some Object typecasting and braces that add very mild verbosity.
The braces are bad: Java should have followed Pythons excellent lead and eliminated them (as long as tab char indenting is mandated to specify blocks; not spaces, spaces chars are evil for indenting, but thats another battle...).This brings up another point: I could write that Java in a one liner as
      for (Object obj : list) System.out.println(obj)if I want to.So how much verbosity is intrinsic to the language, and how much is just due to the style preference of the implementing programmer?</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28168255</id>
	<title>Re:This is totaly stupid</title>
	<author>Anonymous</author>
	<datestamp>1243871940000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>This is not really true. E.g. a language that requires dynamic run-time typing will need to do dynamic run-time type checks in the majority of cases (if it can not statically infer the type, which it usually can't unless the language was designed to support type inference, but then it wouldn't be a dynamic language).</p><p>The language design matters for performance.</p></htmltext>
<tokenext>This is not really true .
E.g. a language that requires dynamic run-time typing will need to do dynamic run-time type checks in the majority of cases ( if it can not statically infer the type , which it usually ca n't unless the language was designed to support type inference , but then it would n't be a dynamic language ) .The language design matters for performance .</tokentext>
<sentencetext>This is not really true.
E.g. a language that requires dynamic run-time typing will need to do dynamic run-time type checks in the majority of cases (if it can not statically infer the type, which it usually can't unless the language was designed to support type inference, but then it wouldn't be a dynamic language).The language design matters for performance.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158899</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767</id>
	<title>Re:What kind of verbosity?</title>
	<author>Anonymous</author>
	<datestamp>1243761180000</datestamp>
	<modclass>Informativ</modclass>
	<modscore>5</modscore>
	<htmltext><tt>Exactly.&nbsp; As an example:<br><br>for item in list:<br>&nbsp; print list<br><br>for(object o in list) {<br>&nbsp; Item item = (Item) o;<br>&nbsp; System.Out.Println(item);<br>}<br><br>for(std::list&lt;Item*&gt; it=list.begin();it!=list.end();it++) {<br>&nbsp; &nbsp;cout &lt;&lt; (*it)-&gt;name &lt;&lt; "\n";<br>}<br><br>Three languages.&nbsp; Same identifiers.&nbsp; Big difference in both verbosity and readability.</tt></htmltext>
<tokenext>Exactly.   As an example : for item in list :   print listfor ( object o in list ) {   Item item = ( Item ) o ;   System.Out.Println ( item ) ; } for ( std : : list it = list.begin ( ) ; it ! = list.end ( ) ; it + + ) {     cout name } Three languages.   Same identifiers.   Big difference in both verbosity and readability .</tokentext>
<sentencetext>Exactly.  As an example:for item in list:  print listfor(object o in list) {  Item item = (Item) o;  System.Out.Println(item);}for(std::list it=list.begin();it!=list.end();it++) {   cout name }Three languages.  Same identifiers.  Big difference in both verbosity and readability.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158425</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28164399</id>
	<title>Re:Forth, the RPN notational programming language</title>
	<author>Anonymous</author>
	<datestamp>1243792560000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>I share your FORTH love.  I worked for almost five years doing FORTH full-time and I really loved the language.</p><p>I didn't have any problems with stack juggling; anything nontrivial, and I would just bust out some temporary variables to clean things up.</p><p>The biggest problems with FORTH as I see it are:</p><p>0) The language is so malleable, people basically write their own domain-specific language, and you need to learn this language before you can work on their code.  It's the same problem we had with this one really malleable text editor: none of us could use each other's editor, because everything was so different.</p><p>1) The language was designed for small programs, and doesn't scale as well as I would like.  Dictionaries are nice, but you really need name spaces and objects.  FORTH is so malleable that I could whip some up, but they should really be standard so that everyone knows how to use everyone else's stuff.</p><p>2) FORTH just never really caught on.  There aren't that many software developers out there who do know FORTH.</p><p>All that said, I agree with you that I would love to see FORTH used as a teaching language.  If you see someone's resume come across your desk, and FORTH is on there as well as C and such languages, you know that person can look at problems in the FORTH way, as well as the more conventional way.  Breadth is good in a software developer.</p><p>I used to think FORTH was the ideal introductory teaching language, because it taught me so much.  But now I think you would be hitting those introductory students over the head (with RPN and the rest of FORTH's quirks), so the first teaching language should be Python (so beautifully clean).  But FORTH is an ideal language for a second-year or third-year undergraduate class.</p></htmltext>
<tokenext>I share your FORTH love .
I worked for almost five years doing FORTH full-time and I really loved the language.I did n't have any problems with stack juggling ; anything nontrivial , and I would just bust out some temporary variables to clean things up.The biggest problems with FORTH as I see it are : 0 ) The language is so malleable , people basically write their own domain-specific language , and you need to learn this language before you can work on their code .
It 's the same problem we had with this one really malleable text editor : none of us could use each other 's editor , because everything was so different.1 ) The language was designed for small programs , and does n't scale as well as I would like .
Dictionaries are nice , but you really need name spaces and objects .
FORTH is so malleable that I could whip some up , but they should really be standard so that everyone knows how to use everyone else 's stuff.2 ) FORTH just never really caught on .
There are n't that many software developers out there who do know FORTH.All that said , I agree with you that I would love to see FORTH used as a teaching language .
If you see someone 's resume come across your desk , and FORTH is on there as well as C and such languages , you know that person can look at problems in the FORTH way , as well as the more conventional way .
Breadth is good in a software developer.I used to think FORTH was the ideal introductory teaching language , because it taught me so much .
But now I think you would be hitting those introductory students over the head ( with RPN and the rest of FORTH 's quirks ) , so the first teaching language should be Python ( so beautifully clean ) .
But FORTH is an ideal language for a second-year or third-year undergraduate class .</tokentext>
<sentencetext>I share your FORTH love.
I worked for almost five years doing FORTH full-time and I really loved the language.I didn't have any problems with stack juggling; anything nontrivial, and I would just bust out some temporary variables to clean things up.The biggest problems with FORTH as I see it are:0) The language is so malleable, people basically write their own domain-specific language, and you need to learn this language before you can work on their code.
It's the same problem we had with this one really malleable text editor: none of us could use each other's editor, because everything was so different.1) The language was designed for small programs, and doesn't scale as well as I would like.
Dictionaries are nice, but you really need name spaces and objects.
FORTH is so malleable that I could whip some up, but they should really be standard so that everyone knows how to use everyone else's stuff.2) FORTH just never really caught on.
There aren't that many software developers out there who do know FORTH.All that said, I agree with you that I would love to see FORTH used as a teaching language.
If you see someone's resume come across your desk, and FORTH is on there as well as C and such languages, you know that person can look at problems in the FORTH way, as well as the more conventional way.
Breadth is good in a software developer.I used to think FORTH was the ideal introductory teaching language, because it taught me so much.
But now I think you would be hitting those introductory students over the head (with RPN and the rest of FORTH's quirks), so the first teaching language should be Python (so beautifully clean).
But FORTH is an ideal language for a second-year or third-year undergraduate class.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159419</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28165021</id>
	<title>Re:Lua?</title>
	<author>grumbel</author>
	<datestamp>1243886760000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>Why isn't it used as often as say, Python, Perl, or Ruby?</p></div><p>You don't chose a language for their syntax, but for most part for their libraries and thus are lacking in Lua. Lua happens to be mostly intended as an language for embedding, not as a stand alone language.</p></div>
	</htmltext>
<tokenext>Why is n't it used as often as say , Python , Perl , or Ruby ? You do n't chose a language for their syntax , but for most part for their libraries and thus are lacking in Lua .
Lua happens to be mostly intended as an language for embedding , not as a stand alone language .</tokentext>
<sentencetext>Why isn't it used as often as say, Python, Perl, or Ruby?You don't chose a language for their syntax, but for most part for their libraries and thus are lacking in Lua.
Lua happens to be mostly intended as an language for embedding, not as a stand alone language.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159289</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28161395</id>
	<title>These benchmarks are bogus</title>
	<author>Anonymous</author>
	<datestamp>1243766460000</datestamp>
	<modclass>Informativ</modclass>
	<modscore>3</modscore>
	<htmltext>All of these numbers are based on what completely flawed microbenchmarks from a site that used to be called "The Language Shootout". The numbers have been thoroughly debunked several times in the past. See this thread, for example: <a href="http://www.javalobby.org/java/forums/t86371.html?start=30" title="javalobby.org" rel="nofollow">http://www.javalobby.org/java/forums/t86371.html?start=30</a> [javalobby.org]

Or just google for "language shootout". It's not that the people who run this are just incompetent (making dumb mistakes like including JVM startup times). It's that they actively allow and even encourage cheating. For example, at least one of the "C" benchmarks actually uses hand-coded assembly (libgmp), and rather than stick to the obvious "program must be written in the language it's listed under" rule, the site maintainer suggests that the "Java" benchmark could be changed to also use assembly. This is all documented in the thread listed above.

After several of these debunkings over the years, they had to change the name from "the language shootout" to something else, as any quick google will show that these benchmarks are completely bogus.

Nothing to see here, move along.</htmltext>
<tokenext>All of these numbers are based on what completely flawed microbenchmarks from a site that used to be called " The Language Shootout " .
The numbers have been thoroughly debunked several times in the past .
See this thread , for example : http : //www.javalobby.org/java/forums/t86371.html ? start = 30 [ javalobby.org ] Or just google for " language shootout " .
It 's not that the people who run this are just incompetent ( making dumb mistakes like including JVM startup times ) .
It 's that they actively allow and even encourage cheating .
For example , at least one of the " C " benchmarks actually uses hand-coded assembly ( libgmp ) , and rather than stick to the obvious " program must be written in the language it 's listed under " rule , the site maintainer suggests that the " Java " benchmark could be changed to also use assembly .
This is all documented in the thread listed above .
After several of these debunkings over the years , they had to change the name from " the language shootout " to something else , as any quick google will show that these benchmarks are completely bogus .
Nothing to see here , move along .</tokentext>
<sentencetext>All of these numbers are based on what completely flawed microbenchmarks from a site that used to be called "The Language Shootout".
The numbers have been thoroughly debunked several times in the past.
See this thread, for example: http://www.javalobby.org/java/forums/t86371.html?start=30 [javalobby.org]

Or just google for "language shootout".
It's not that the people who run this are just incompetent (making dumb mistakes like including JVM startup times).
It's that they actively allow and even encourage cheating.
For example, at least one of the "C" benchmarks actually uses hand-coded assembly (libgmp), and rather than stick to the obvious "program must be written in the language it's listed under" rule, the site maintainer suggests that the "Java" benchmark could be changed to also use assembly.
This is all documented in the thread listed above.
After several of these debunkings over the years, they had to change the name from "the language shootout" to something else, as any quick google will show that these benchmarks are completely bogus.
Nothing to see here, move along.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28162647</id>
	<title>Java is fast</title>
	<author>codepunk</author>
	<datestamp>1243777740000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Java is smoking fast as long as the machine running it has a TB of ram for each hello world app.</p></htmltext>
<tokenext>Java is smoking fast as long as the machine running it has a TB of ram for each hello world app .</tokentext>
<sentencetext>Java is smoking fast as long as the machine running it has a TB of ram for each hello world app.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158331</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28169407</id>
	<title>Re:What kind of verbosity?</title>
	<author>Anonymous</author>
	<datestamp>1243876860000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p><div class="quote"><p>I prefer<br><tt>print foreach @list;</tt><br>though. Perl FTW as usual<nobr> <wbr></nobr>:)</p></div><p>or with 5.10</p><p><tt>say "@list";</tt></p></div>
	</htmltext>
<tokenext>I preferprint foreach @ list ; though .
Perl FTW as usual : ) or with 5.10say " @ list " ;</tokentext>
<sentencetext>I preferprint foreach @list;though.
Perl FTW as usual :)or with 5.10say "@list";
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28162767</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28164223</id>
	<title>Re:What kind of verbosity?</title>
	<author>Anonymous</author>
	<datestamp>1243790820000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>(map print list)</p></htmltext>
<tokenext>( map print list )</tokentext>
<sentencetext>(map print list)</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28161003</id>
	<title>Re:Ruby</title>
	<author>wumpus188</author>
	<datestamp>1243762800000</datestamp>
	<modclass>Flamebait</modclass>
	<modscore>0</modscore>
	<htmltext>Because speed is not everything.</htmltext>
<tokenext>Because speed is not everything .</tokentext>
<sentencetext>Because speed is not everything.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158689</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28161105</id>
	<title>Re:The perfect language exists, you ignorant clod!</title>
	<author>KangKong</author>
	<datestamp>1243763700000</datestamp>
	<modclass>Informativ</modclass>
	<modscore>2</modscore>
	<htmltext><p><a href="http://lolcode.com/" title="lolcode.com" rel="nofollow">http://lolcode.com/</a> [lolcode.com]</p></htmltext>
<tokenext>http : //lolcode.com/ [ lolcode.com ]</tokentext>
<sentencetext>http://lolcode.com/ [lolcode.com]</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158335</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158377</id>
	<title>Forth, the RPN notational programming language</title>
	<author>RichMan</author>
	<datestamp>1243786260000</datestamp>
	<modclass>Informativ</modclass>
	<modscore>4</modscore>
	<htmltext><p><a href="http://en.wikipedia.org/wiki/Forth\_(programming\_language)" title="wikipedia.org">http://en.wikipedia.org/wiki/Forth\_(programming\_language)</a> [wikipedia.org]</p><p>--<br>Forth is a simple yet extensible language; its modularity and extensibility permit the writing of high-level programs such as CAD systems. However, extensibility also helps poor programmers to write incomprehensible code, which has given Forth a reputation as a "write-only language". Forth has been used successfully in large, complex projects, while applications developed by competent, disciplined professionals have proven to be easily maintained on evolving hardware platforms over decades of use<br>--<br>Forth is still used today in many embedded systems (small computerized devices) because of its portability, efficient memory use, short development time, and fast execution speed. It has been implemented efficiently on modern RISC processors, and processors that use Forth as machine language have been produced<br>--</p></htmltext>
<tokenext>http : //en.wikipedia.org/wiki/Forth \ _ ( programming \ _language ) [ wikipedia.org ] --Forth is a simple yet extensible language ; its modularity and extensibility permit the writing of high-level programs such as CAD systems .
However , extensibility also helps poor programmers to write incomprehensible code , which has given Forth a reputation as a " write-only language " .
Forth has been used successfully in large , complex projects , while applications developed by competent , disciplined professionals have proven to be easily maintained on evolving hardware platforms over decades of use--Forth is still used today in many embedded systems ( small computerized devices ) because of its portability , efficient memory use , short development time , and fast execution speed .
It has been implemented efficiently on modern RISC processors , and processors that use Forth as machine language have been produced--</tokentext>
<sentencetext>http://en.wikipedia.org/wiki/Forth\_(programming\_language) [wikipedia.org]--Forth is a simple yet extensible language; its modularity and extensibility permit the writing of high-level programs such as CAD systems.
However, extensibility also helps poor programmers to write incomprehensible code, which has given Forth a reputation as a "write-only language".
Forth has been used successfully in large, complex projects, while applications developed by competent, disciplined professionals have proven to be easily maintained on evolving hardware platforms over decades of use--Forth is still used today in many embedded systems (small computerized devices) because of its portability, efficient memory use, short development time, and fast execution speed.
It has been implemented efficiently on modern RISC processors, and processors that use Forth as machine language have been produced--</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159315</id>
	<title>Re:Ruby</title>
	<author>s\_p\_oneil</author>
	<datestamp>1243793880000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>I'll give you a few reasons:<br>1) Often the amount of time it takes you to code something is WAY more important than performance.<br>2) How clean and easy a program is to maintain is often even more important.<br>3) When performance is more important, you probably shouldn't be using a scripting language (or you should go with Lua).<br>4) JRuby and YARV (different versions of Ruby) are much faster, and the latest Ruby 1.9.1 is even faster than those.<br>5) If you can stand to extend Ruby in C or with COM objects (it's not that hard), Ruby 1.9.1 will do just about anything you want, and you can control performance by writing the slow parts in C. Your only real problem would be using bloated frameworks like Rails, which can't be sped up so easily.<br>6) If you can't stand to extend it in C or with COM objects, or if you need native threads, use JRuby. If a piece of Ruby code runs too slow in Ruby, convert it to Java. JRuby doesn't care whether an object is a Java object or a Ruby object.</p><p>"Why can't they make a language, or extend a language like Ruby, such that one can program it as a scripting language, but then add verbosity optionally (i.e. declaring the data types and their sizes, private / static etc. &amp; whatever the hell makes a program light weight and fast) optionally?"</p><p>They already have that. It's called JRuby. Even better than what you suggested, JRuby supports native threads. Run it with an Apache+Tomcat server and watch it put normal Ruby-based web apps to shame in terms of scalability and ease of deployment (probably in terms of reliability, too).</p></htmltext>
<tokenext>I 'll give you a few reasons : 1 ) Often the amount of time it takes you to code something is WAY more important than performance.2 ) How clean and easy a program is to maintain is often even more important.3 ) When performance is more important , you probably should n't be using a scripting language ( or you should go with Lua ) .4 ) JRuby and YARV ( different versions of Ruby ) are much faster , and the latest Ruby 1.9.1 is even faster than those.5 ) If you can stand to extend Ruby in C or with COM objects ( it 's not that hard ) , Ruby 1.9.1 will do just about anything you want , and you can control performance by writing the slow parts in C. Your only real problem would be using bloated frameworks like Rails , which ca n't be sped up so easily.6 ) If you ca n't stand to extend it in C or with COM objects , or if you need native threads , use JRuby .
If a piece of Ruby code runs too slow in Ruby , convert it to Java .
JRuby does n't care whether an object is a Java object or a Ruby object .
" Why ca n't they make a language , or extend a language like Ruby , such that one can program it as a scripting language , but then add verbosity optionally ( i.e .
declaring the data types and their sizes , private / static etc .
&amp; whatever the hell makes a program light weight and fast ) optionally ?
" They already have that .
It 's called JRuby .
Even better than what you suggested , JRuby supports native threads .
Run it with an Apache + Tomcat server and watch it put normal Ruby-based web apps to shame in terms of scalability and ease of deployment ( probably in terms of reliability , too ) .</tokentext>
<sentencetext>I'll give you a few reasons:1) Often the amount of time it takes you to code something is WAY more important than performance.2) How clean and easy a program is to maintain is often even more important.3) When performance is more important, you probably shouldn't be using a scripting language (or you should go with Lua).4) JRuby and YARV (different versions of Ruby) are much faster, and the latest Ruby 1.9.1 is even faster than those.5) If you can stand to extend Ruby in C or with COM objects (it's not that hard), Ruby 1.9.1 will do just about anything you want, and you can control performance by writing the slow parts in C. Your only real problem would be using bloated frameworks like Rails, which can't be sped up so easily.6) If you can't stand to extend it in C or with COM objects, or if you need native threads, use JRuby.
If a piece of Ruby code runs too slow in Ruby, convert it to Java.
JRuby doesn't care whether an object is a Java object or a Ruby object.
"Why can't they make a language, or extend a language like Ruby, such that one can program it as a scripting language, but then add verbosity optionally (i.e.
declaring the data types and their sizes, private / static etc.
&amp; whatever the hell makes a program light weight and fast) optionally?
"They already have that.
It's called JRuby.
Even better than what you suggested, JRuby supports native threads.
Run it with an Apache+Tomcat server and watch it put normal Ruby-based web apps to shame in terms of scalability and ease of deployment (probably in terms of reliability, too).</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158689</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158387</id>
	<title>Verbosity is bad because</title>
	<author>Limerent Oil</author>
	<datestamp>1243786380000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>3</modscore>
	<htmltext><p>Verbosity = ( 1 / Expressiveness )</p></htmltext>
<tokenext>Verbosity = ( 1 / Expressiveness )</tokentext>
<sentencetext>Verbosity = ( 1 / Expressiveness )</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158223</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158785</id>
	<title>Where's brainfuck?</title>
	<author>xtrafe</author>
	<datestamp>1243789680000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>I, for one, am disappointed that a whole <a href="http://esoteric.voxelperfect.net/wiki/Category:Brainfuck\_derivatives" title="voxelperfect.net" rel="nofollow">treasure trove</a> [voxelperfect.net] of languages was ignored by this study.</htmltext>
<tokenext>I , for one , am disappointed that a whole treasure trove [ voxelperfect.net ] of languages was ignored by this study .</tokentext>
<sentencetext>I, for one, am disappointed that a whole treasure trove [voxelperfect.net] of languages was ignored by this study.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158465</id>
	<title>Re:Why is Verbosity Bad?</title>
	<author>Anonymous</author>
	<datestamp>1243786980000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>My guess is that the benchmarked code is assumed to have pretty much the same "verbosity density", so code size then directly reflects the ability of the language to express ideas concisely. Example...</p><p>Pascal:<br>itemCounts[ProductIdFromName(name)]<nobr> <wbr></nobr>:= itemCounts[ProductIdFromName(name)] + 1;</p><p>C:<br>itemCounts[ProductIdFromName(name)]++;</p></htmltext>
<tokenext>My guess is that the benchmarked code is assumed to have pretty much the same " verbosity density " , so code size then directly reflects the ability of the language to express ideas concisely .
Example...Pascal : itemCounts [ ProductIdFromName ( name ) ] : = itemCounts [ ProductIdFromName ( name ) ] + 1 ; C : itemCounts [ ProductIdFromName ( name ) ] + + ;</tokentext>
<sentencetext>My guess is that the benchmarked code is assumed to have pretty much the same "verbosity density", so code size then directly reflects the ability of the language to express ideas concisely.
Example...Pascal:itemCounts[ProductIdFromName(name)] := itemCounts[ProductIdFromName(name)] + 1;C:itemCounts[ProductIdFromName(name)]++;</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158223</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160121</id>
	<title>Re:This is totaly stupid</title>
	<author>mr exploiter</author>
	<datestamp>1243799820000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>Thinking that the design of a programming language is independent of how fast the code written on it runs is at least ignorant. There are some obvious differences between compiled/interpeted languages, and even with JIT compilers, there are some languages that simply are not well prepared to be optimized like others.</htmltext>
<tokenext>Thinking that the design of a programming language is independent of how fast the code written on it runs is at least ignorant .
There are some obvious differences between compiled/interpeted languages , and even with JIT compilers , there are some languages that simply are not well prepared to be optimized like others .</tokentext>
<sentencetext>Thinking that the design of a programming language is independent of how fast the code written on it runs is at least ignorant.
There are some obvious differences between compiled/interpeted languages, and even with JIT compilers, there are some languages that simply are not well prepared to be optimized like others.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158899</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160417</id>
	<title>Re:Scala</title>
	<author>shutdown -p now</author>
	<datestamp>1243802040000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>I am surprised how they manage to get scala to perform so much worse than pure java.</p></div><p>I haven't looked at their code, but I do have some suspicions.</p><p>Scala allows and promotes some programming techniques that, while possible in Java, are too cumbersome to be used in practice - such as first-class functions and the associated FP patterns. However, JVM is not optimized for such things, so using them might lead to a significant performance penalty.</p><p>To give a single example: a Java for-loop over a collection is noticeably faster than using generalized map/filter/fold. However, when coding in Scala, you are more likely to use the latter.</p></div>
	</htmltext>
<tokenext>I am surprised how they manage to get scala to perform so much worse than pure java.I have n't looked at their code , but I do have some suspicions.Scala allows and promotes some programming techniques that , while possible in Java , are too cumbersome to be used in practice - such as first-class functions and the associated FP patterns .
However , JVM is not optimized for such things , so using them might lead to a significant performance penalty.To give a single example : a Java for-loop over a collection is noticeably faster than using generalized map/filter/fold .
However , when coding in Scala , you are more likely to use the latter .</tokentext>
<sentencetext>I am surprised how they manage to get scala to perform so much worse than pure java.I haven't looked at their code, but I do have some suspicions.Scala allows and promotes some programming techniques that, while possible in Java, are too cumbersome to be used in practice - such as first-class functions and the associated FP patterns.
However, JVM is not optimized for such things, so using them might lead to a significant performance penalty.To give a single example: a Java for-loop over a collection is noticeably faster than using generalized map/filter/fold.
However, when coding in Scala, you are more likely to use the latter.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158307</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28162767</id>
	<title>Re:What kind of verbosity?</title>
	<author>rrohbeck</author>
	<datestamp>1243779000000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>3</modscore>
	<htmltext><p>I prefer<br><tt>print foreach @list;</tt><br>though. Perl FTW as usual<nobr> <wbr></nobr>:)</p></htmltext>
<tokenext>I preferprint foreach @ list ; though .
Perl FTW as usual : )</tokentext>
<sentencetext>I preferprint foreach @list;though.
Perl FTW as usual :)</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159099</id>
	<title>Re:Ocaml</title>
	<author>Anonymous</author>
	<datestamp>1243792200000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>1</modscore>
	<htmltext><p>Ocaml can be used as an imperative language. Try that. Try to avoid using any "map" or something like that. You will end up in clean, elegant and *fast* code anyway.</p><p>Ocaml is a functional, imperative and object-oriented language. The oo-style of ocaml is impressing. The type is driven by the available methods, not by the name of a class. This makes coding object-oriented imperative programs in OCaml a funny and quick task.</p><p>If you *also* know how to make advantage of functional programming, you still can, with one of the most advanced functional programming language available.</p><p>If you don't know how to avoid stack overflow it's better you stick with imperative code, but using a language such as OCaml will make you more productive in any case.</p></htmltext>
<tokenext>Ocaml can be used as an imperative language .
Try that .
Try to avoid using any " map " or something like that .
You will end up in clean , elegant and * fast * code anyway.Ocaml is a functional , imperative and object-oriented language .
The oo-style of ocaml is impressing .
The type is driven by the available methods , not by the name of a class .
This makes coding object-oriented imperative programs in OCaml a funny and quick task.If you * also * know how to make advantage of functional programming , you still can , with one of the most advanced functional programming language available.If you do n't know how to avoid stack overflow it 's better you stick with imperative code , but using a language such as OCaml will make you more productive in any case .</tokentext>
<sentencetext>Ocaml can be used as an imperative language.
Try that.
Try to avoid using any "map" or something like that.
You will end up in clean, elegant and *fast* code anyway.Ocaml is a functional, imperative and object-oriented language.
The oo-style of ocaml is impressing.
The type is driven by the available methods, not by the name of a class.
This makes coding object-oriented imperative programs in OCaml a funny and quick task.If you *also* know how to make advantage of functional programming, you still can, with one of the most advanced functional programming language available.If you don't know how to avoid stack overflow it's better you stick with imperative code, but using a language such as OCaml will make you more productive in any case.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158731</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158551</id>
	<title>Re:Pet peeve</title>
	<author>sunderland56</author>
	<datestamp>1243787700000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>The article does confuse a language with it's implementation. GCC, for instance, is NOT a language!</htmltext>
<tokenext>The article does confuse a language with it 's implementation .
GCC , for instance , is NOT a language !</tokentext>
<sentencetext>The article does confuse a language with it's implementation.
GCC, for instance, is NOT a language!</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158375</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28165231</id>
	<title>Re:What kind of verbosity?</title>
	<author>Anonymous</author>
	<datestamp>1243847280000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>C++0x<nobr> <wbr></nobr>:)<br>for(auto item : list)<br>{<br>
&nbsp; &nbsp; &nbsp; &nbsp; std::cout &lt;&lt; *item &lt;&lt; std::endl;<br>}</p></htmltext>
<tokenext>C + + 0x : ) for ( auto item : list ) {         std : : cout }</tokentext>
<sentencetext>C++0x :)for(auto item : list){
        std::cout }</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158575</id>
	<title>Ocaml</title>
	<author>Anonymous</author>
	<datestamp>1243787940000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>3</modscore>
	<htmltext><p>Every time I see one of these things, OCaml always rocks it.  I wonder why it never caught on to a greater degree?</p></htmltext>
<tokenext>Every time I see one of these things , OCaml always rocks it .
I wonder why it never caught on to a greater degree ?</tokentext>
<sentencetext>Every time I see one of these things, OCaml always rocks it.
I wonder why it never caught on to a greater degree?</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158961</id>
	<title>Re:Scala</title>
	<author>Ichoran</author>
	<datestamp>1243791000000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I am surprised that the benchmarks perform so much worse *without* being significantly more compact.  If you're going to write compact functional code, you have to accept a bit (or a lot) of overhead.  But there's no reason a Scala program should be both longer and slower than a Java one except through inattention.</p></htmltext>
<tokenext>I am surprised that the benchmarks perform so much worse * without * being significantly more compact .
If you 're going to write compact functional code , you have to accept a bit ( or a lot ) of overhead .
But there 's no reason a Scala program should be both longer and slower than a Java one except through inattention .</tokentext>
<sentencetext>I am surprised that the benchmarks perform so much worse *without* being significantly more compact.
If you're going to write compact functional code, you have to accept a bit (or a lot) of overhead.
But there's no reason a Scala program should be both longer and slower than a Java one except through inattention.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158307</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28163213</id>
	<title>Re:What kind of verbosity?</title>
	<author>ruroshin</author>
	<datestamp>1243782360000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>for(object o in list) {<br>
&nbsp; Item item = (Item) o;<br>
&nbsp; System.Out.Println(item);<br>}</p></div><p>For a one liner you don't need the brackets and you don't have to cast objects if the list was properly declared.  You could write above:</p><p>for(Item item: list)<br>
&nbsp; &nbsp; System.out.println(item);</p></div>
	</htmltext>
<tokenext>for ( object o in list ) {   Item item = ( Item ) o ;   System.Out.Println ( item ) ; } For a one liner you do n't need the brackets and you do n't have to cast objects if the list was properly declared .
You could write above : for ( Item item : list )     System.out.println ( item ) ;</tokentext>
<sentencetext>for(object o in list) {
  Item item = (Item) o;
  System.Out.Println(item);}For a one liner you don't need the brackets and you don't have to cast objects if the list was properly declared.
You could write above:for(Item item: list)
    System.out.println(item);
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158425</id>
	<title>What kind of verbosity?</title>
	<author>Timothy Brownawell</author>
	<datestamp>1243786680000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>5</modscore>
	<htmltext><p><div class="quote"><p>I think verbosity in moderation is necessary. I have read many an article with developers arguing that they don't need to document their code when their code is self-documenting. Do you make all of your variables and class/function/methods a single character for the sake of verbosity? I hope not. And I would think that reading and maintaining that code would be far less than a joy.</p></div><p>Long meaningful identifiers are useful. Needing 5 lines of setup for each API call is annoying, particularly if those 5 lines are usually the same. Requiring lots of redundant long keywords to "look more like English" is annoying. Large standard libraries that let you remove most of the tedious parts from your code are useful.</p></div>
	</htmltext>
<tokenext>I think verbosity in moderation is necessary .
I have read many an article with developers arguing that they do n't need to document their code when their code is self-documenting .
Do you make all of your variables and class/function/methods a single character for the sake of verbosity ?
I hope not .
And I would think that reading and maintaining that code would be far less than a joy.Long meaningful identifiers are useful .
Needing 5 lines of setup for each API call is annoying , particularly if those 5 lines are usually the same .
Requiring lots of redundant long keywords to " look more like English " is annoying .
Large standard libraries that let you remove most of the tedious parts from your code are useful .</tokentext>
<sentencetext>I think verbosity in moderation is necessary.
I have read many an article with developers arguing that they don't need to document their code when their code is self-documenting.
Do you make all of your variables and class/function/methods a single character for the sake of verbosity?
I hope not.
And I would think that reading and maintaining that code would be far less than a joy.Long meaningful identifiers are useful.
Needing 5 lines of setup for each API call is annoying, particularly if those 5 lines are usually the same.
Requiring lots of redundant long keywords to "look more like English" is annoying.
Large standard libraries that let you remove most of the tedious parts from your code are useful.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158223</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28165437</id>
	<title>GNAT</title>
	<author>krischik</author>
	<datestamp>1243850640000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>The benchmark list compiler names and not language names. And this quite right as compiler implementations are compared.</p><p>Ada is therefore GNAT. And the other questions often asked: Fortran is g95.</p><p>Martin</p><p>PS: Of course the hole Blog is therefore wrong. It's title should relay be <i>The speed, size and dependability of programming languages <b>implementations.</b> </i></p></htmltext>
<tokenext>The benchmark list compiler names and not language names .
And this quite right as compiler implementations are compared.Ada is therefore GNAT .
And the other questions often asked : Fortran is g95.MartinPS : Of course the hole Blog is therefore wrong .
It 's title should relay be The speed , size and dependability of programming languages implementations .</tokentext>
<sentencetext>The benchmark list compiler names and not language names.
And this quite right as compiler implementations are compared.Ada is therefore GNAT.
And the other questions often asked: Fortran is g95.MartinPS: Of course the hole Blog is therefore wrong.
It's title should relay be The speed, size and dependability of programming languages implementations. </sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158755</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28165035</id>
	<title>Re:A language does not have performance</title>
	<author>dcam</author>
	<datestamp>1243886820000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>That is incorrect. A language may enforce limitations on the compiler that may block it from further optimisation.</p></htmltext>
<tokenext>That is incorrect .
A language may enforce limitations on the compiler that may block it from further optimisation .</tokentext>
<sentencetext>That is incorrect.
A language may enforce limitations on the compiler that may block it from further optimisation.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160159</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158331</id>
	<title>Java</title>
	<author>Allicorn</author>
	<datestamp>1243785960000</datestamp>
	<modclass>Funny</modclass>
	<modscore>2</modscore>
	<htmltext><p>Oh but Java is a plodding, stumbling, lumbering, slug of slowness. All thoroughly indoctrinated Slashdotters know that already. No need to RTFA...</p></htmltext>
<tokenext>Oh but Java is a plodding , stumbling , lumbering , slug of slowness .
All thoroughly indoctrinated Slashdotters know that already .
No need to RTFA.. .</tokentext>
<sentencetext>Oh but Java is a plodding, stumbling, lumbering, slug of slowness.
All thoroughly indoctrinated Slashdotters know that already.
No need to RTFA...</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159365</id>
	<title>Re:Ada</title>
	<author>Anonymous</author>
	<datestamp>1243794300000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext>Here: <a href="http://en.wikipedia.org/wiki/Church\_of\_St.\_Mary\_Magdalene,\_Hucknall" title="wikipedia.org" rel="nofollow">http://en.wikipedia.org/wiki/Church\_of\_St.\_Mary\_Magdalene,\_Hucknall</a> [wikipedia.org]</htmltext>
<tokenext>Here : http : //en.wikipedia.org/wiki/Church \ _of \ _St. \ _Mary \ _Magdalene , \ _Hucknall [ wikipedia.org ]</tokentext>
<sentencetext>Here: http://en.wikipedia.org/wiki/Church\_of\_St.\_Mary\_Magdalene,\_Hucknall [wikipedia.org]</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158755</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28161151</id>
	<title>Re:what about APL</title>
	<author>jd</author>
	<datestamp>1243764240000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>It's interesting that Occam (I presume they used the KROC implementation, owing to the lack of handy transputers) outperforms C in some situations. Occam is designed to be highly parallel, etc, etc, ad nausium, but it hasn't had nearly the same level of development work and optimization work as C.</p></htmltext>
<tokenext>It 's interesting that Occam ( I presume they used the KROC implementation , owing to the lack of handy transputers ) outperforms C in some situations .
Occam is designed to be highly parallel , etc , etc , ad nausium , but it has n't had nearly the same level of development work and optimization work as C .</tokentext>
<sentencetext>It's interesting that Occam (I presume they used the KROC implementation, owing to the lack of handy transputers) outperforms C in some situations.
Occam is designed to be highly parallel, etc, etc, ad nausium, but it hasn't had nearly the same level of development work and optimization work as C.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158219</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160557</id>
	<title>Re:Ocaml</title>
	<author>HiThere</author>
	<datestamp>1243803120000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Because it isn't clear how to write a file?</p><p>When I looked I couldn't figure out how to write fixed length binary records to calculated locations.  Something involving monads is all I could guess, but I still don't know what a monad is.  Leibniz talked about monads as having no externals (no I/O ports?), but I'm not sure this is what OCaML meant.</p></htmltext>
<tokenext>Because it is n't clear how to write a file ? When I looked I could n't figure out how to write fixed length binary records to calculated locations .
Something involving monads is all I could guess , but I still do n't know what a monad is .
Leibniz talked about monads as having no externals ( no I/O ports ?
) , but I 'm not sure this is what OCaML meant .</tokentext>
<sentencetext>Because it isn't clear how to write a file?When I looked I couldn't figure out how to write fixed length binary records to calculated locations.
Something involving monads is all I could guess, but I still don't know what a monad is.
Leibniz talked about monads as having no externals (no I/O ports?
), but I'm not sure this is what OCaML meant.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158575</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158845</id>
	<title>I wasn't aware...</title>
	<author>Anonymous</author>
	<datestamp>1243790100000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>...that only languages that only remain in usage due to rewriting the programs written in them being too expensive to justify doing so counted as "real languages".</p></htmltext>
<tokenext>...that only languages that only remain in usage due to rewriting the programs written in them being too expensive to justify doing so counted as " real languages " .</tokentext>
<sentencetext>...that only languages that only remain in usage due to rewriting the programs written in them being too expensive to justify doing so counted as "real languages".</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158405</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28162657</id>
	<title>Re:What kind of verbosity?</title>
	<author>Tweenk</author>
	<datestamp>1243777800000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>None of the examples work. It should have been:</p><p>for item in list:<br>
&nbsp; &nbsp; print "\n".join([str(x) for x in item])</p><p>for(Item o : list) {<br>
&nbsp; &nbsp; System.out.println(item);<br>}<br>(if it was Java)</p><p>for(std::list&lt;Item*&gt;::iterator it = list.begin(); it != list.end(); ++it) {<br>
&nbsp; &nbsp; &nbsp; cout &lt;&lt; *it &lt;&lt; "\n";<br>}<br>(assuming Item has operator&lt;&lt; overloaded for stream output)</p></htmltext>
<tokenext>None of the examples work .
It should have been : for item in list :     print " \ n " .join ( [ str ( x ) for x in item ] ) for ( Item o : list ) {     System.out.println ( item ) ; } ( if it was Java ) for ( std : : list : : iterator it = list.begin ( ) ; it ! = list.end ( ) ; + + it ) {       cout } ( assuming Item has operator</tokentext>
<sentencetext>None of the examples work.
It should have been:for item in list:
    print "\n".join([str(x) for x in item])for(Item o : list) {
    System.out.println(item);}(if it was Java)for(std::list::iterator it = list.begin(); it != list.end(); ++it) {
      cout }(assuming Item has operator</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158615</id>
	<title>Re:Where are the real lanaguages???</title>
	<author>Anonymous</author>
	<datestamp>1243788240000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Top right.</p></htmltext>
<tokenext>Top right .</tokentext>
<sentencetext>Top right.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158405</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28170071</id>
	<title>Re:What kind of verbosity?</title>
	<author>cadu</author>
	<datestamp>1243879980000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>for item in list:<br>
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; print list</p><p>------program output--------</p><p>Oops!Oops!Oops!Oops!Oops!Oops!Oops!Oops!<br>Oops!Oops!Oops!Oops!Oops!Oops!Oops!Oops!<br>Oops!Oops!Oops!Oops!Oops!Oops!Oops!Oops!<br>Oops!Oops!Oops!Oops!Oops!Oops!Oops!Oops!<br>Oops!Oops!Oops!Oops!Oops!Oops!Oops!Oops!<br>FAIL!FAIL!FAIL!FAIL!FAIL!FAIL!FAIL!FAIL!</p></htmltext>
<tokenext>for item in list :                                             print list------program output--------Oops ! Oops ! Oops ! Oops ! Oops ! Oops ! Oops ! Oops ! Oops ! Oops ! Oops ! Oops ! Oops ! Oops ! Oops ! Oops ! Oops ! Oops ! Oops ! Oops ! Oops ! Oops ! Oops ! Oops ! Oops ! Oops ! Oops ! Oops ! Oops ! Oops ! Oops ! Oops ! Oops ! Oops ! Oops ! Oops ! Oops ! Oops ! Oops ! Oops ! FAIL ! FAIL ! FAIL ! FAIL ! FAIL ! FAIL ! FAIL ! FAIL !</tokentext>
<sentencetext>for item in list:
                                            print list------program output--------Oops!Oops!Oops!Oops!Oops!Oops!Oops!Oops!Oops!Oops!Oops!Oops!Oops!Oops!Oops!Oops!Oops!Oops!Oops!Oops!Oops!Oops!Oops!Oops!Oops!Oops!Oops!Oops!Oops!Oops!Oops!Oops!Oops!Oops!Oops!Oops!Oops!Oops!Oops!Oops!FAIL!FAIL!FAIL!FAIL!FAIL!FAIL!FAIL!FAIL!</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159211</id>
	<title>Re:What kind of verbosity?</title>
	<author>ls671</author>
	<datestamp>1243793100000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>No language will have APIs for all you might want to do in order for you to use only one line of code !</p><p>This is why they teach how to build custom utility methods in schools. In fact, the first time that you repeat 3 or 4 lines of code in your work means it is time to write a utility method.</p><p>Be careful although,  one should always check that this functionality isn't already implemented in standard libraries in order to avoid re-inventing the wheel.</p></htmltext>
<tokenext>No language will have APIs for all you might want to do in order for you to use only one line of code ! This is why they teach how to build custom utility methods in schools .
In fact , the first time that you repeat 3 or 4 lines of code in your work means it is time to write a utility method.Be careful although , one should always check that this functionality is n't already implemented in standard libraries in order to avoid re-inventing the wheel .</tokentext>
<sentencetext>No language will have APIs for all you might want to do in order for you to use only one line of code !This is why they teach how to build custom utility methods in schools.
In fact, the first time that you repeat 3 or 4 lines of code in your work means it is time to write a utility method.Be careful although,  one should always check that this functionality isn't already implemented in standard libraries in order to avoid re-inventing the wheel.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158425</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28175869</id>
	<title>Re:Forth, the RPN notational programming language</title>
	<author>Kazoo the Clown</author>
	<datestamp>1243861440000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>I also spent much of the '80s in Forth.  But as far as a teaching language, I'd say they ought to stick to Lisp for that sort of thing.  They're similarly extensible, and I suspect Lisp will be more likely to stand the test of time...</htmltext>
<tokenext>I also spent much of the '80s in Forth .
But as far as a teaching language , I 'd say they ought to stick to Lisp for that sort of thing .
They 're similarly extensible , and I suspect Lisp will be more likely to stand the test of time.. .</tokentext>
<sentencetext>I also spent much of the '80s in Forth.
But as far as a teaching language, I'd say they ought to stick to Lisp for that sort of thing.
They're similarly extensible, and I suspect Lisp will be more likely to stand the test of time...</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159419</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28163093</id>
	<title>Re:What kind of verbosity?</title>
	<author>dpilot</author>
	<datestamp>1243781280000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Oh, come on.  If you're going to be terse about printing a list, nothing beats APL.</p><p>Unfortunately I haven't touched APL in a quarter century, and can't remember how to print.  However, if console output is sufficient, here's how to print the contents of "list" in APL.</p><p>list</p></htmltext>
<tokenext>Oh , come on .
If you 're going to be terse about printing a list , nothing beats APL.Unfortunately I have n't touched APL in a quarter century , and ca n't remember how to print .
However , if console output is sufficient , here 's how to print the contents of " list " in APL.list</tokentext>
<sentencetext>Oh, come on.
If you're going to be terse about printing a list, nothing beats APL.Unfortunately I haven't touched APL in a quarter century, and can't remember how to print.
However, if console output is sufficient, here's how to print the contents of "list" in APL.list</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28164349</id>
	<title>Re:This is totaly stupid</title>
	<author>ignavus</author>
	<datestamp>1243792080000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Which programming language helps you write (and maintain) useful code the fastest?</p><p>Which programming language COMPILER helps you compile code the fastest?</p><p>Which programming language COMPILER produces the fastest binaries?</p><p>Three different questions about performance. Only the first one is about "programming languages" per se.</p><p>I find that I can whip up a prototype program faster in PHP than in C (using PHP in its command line mode). But C binaries run much faster than PHP scripts. So it depends on whether I want faster development time or faster execution time.</p></htmltext>
<tokenext>Which programming language helps you write ( and maintain ) useful code the fastest ? Which programming language COMPILER helps you compile code the fastest ? Which programming language COMPILER produces the fastest binaries ? Three different questions about performance .
Only the first one is about " programming languages " per se.I find that I can whip up a prototype program faster in PHP than in C ( using PHP in its command line mode ) .
But C binaries run much faster than PHP scripts .
So it depends on whether I want faster development time or faster execution time .</tokentext>
<sentencetext>Which programming language helps you write (and maintain) useful code the fastest?Which programming language COMPILER helps you compile code the fastest?Which programming language COMPILER produces the fastest binaries?Three different questions about performance.
Only the first one is about "programming languages" per se.I find that I can whip up a prototype program faster in PHP than in C (using PHP in its command line mode).
But C binaries run much faster than PHP scripts.
So it depends on whether I want faster development time or faster execution time.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158899</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159009</id>
	<title>Re:Ruby</title>
	<author>Anonymous</author>
	<datestamp>1243791420000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>You're missing the whole point of the language. Ruby is a language for problems where development speed is more important than run-time speed.</p><p>Besides, there's nothing stopping you from coding the bottlenecks in C.</p></htmltext>
<tokenext>You 're missing the whole point of the language .
Ruby is a language for problems where development speed is more important than run-time speed.Besides , there 's nothing stopping you from coding the bottlenecks in C .</tokentext>
<sentencetext>You're missing the whole point of the language.
Ruby is a language for problems where development speed is more important than run-time speed.Besides, there's nothing stopping you from coding the bottlenecks in C.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158689</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158307</id>
	<title>Scala</title>
	<author>Laz10</author>
	<datestamp>1243785660000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>3</modscore>
	<htmltext><tt>I am surprised how they manage to get scala to perform so much worse than pure java.<br><br>Scala compiles to pure java<nobr> <wbr></nobr>.class files and uses static typing and the makes claim that the bytecodes are almost identical.<br><br>I wonder if the benchmarks are executed in the same environment.<br>http://shootout.alioth.debian.org/ has a Gentoo label behind the java benchmarks, but not the Scala one.<br><br></tt></htmltext>
<tokenext>I am surprised how they manage to get scala to perform so much worse than pure java.Scala compiles to pure java .class files and uses static typing and the makes claim that the bytecodes are almost identical.I wonder if the benchmarks are executed in the same environment.http : //shootout.alioth.debian.org/ has a Gentoo label behind the java benchmarks , but not the Scala one .</tokentext>
<sentencetext>I am surprised how they manage to get scala to perform so much worse than pure java.Scala compiles to pure java .class files and uses static typing and the makes claim that the bytecodes are almost identical.I wonder if the benchmarks are executed in the same environment.http://shootout.alioth.debian.org/ has a Gentoo label behind the java benchmarks, but not the Scala one.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28171657</id>
	<title>Re:Forth, the RPN notational programming language</title>
	<author>skeeto</author>
	<datestamp>1243886760000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>2</modscore>
	<htmltext>If you like Forth, you should check out <a href="http://factorcode.org/" title="factorcode.org">Factor</a> [factorcode.org], which is basically a modernized version of Forth (dynamically typed, no *very* low level filesystem junk that Forth has). I've recently started playing with it.</htmltext>
<tokenext>If you like Forth , you should check out Factor [ factorcode.org ] , which is basically a modernized version of Forth ( dynamically typed , no * very * low level filesystem junk that Forth has ) .
I 've recently started playing with it .</tokentext>
<sentencetext>If you like Forth, you should check out Factor [factorcode.org], which is basically a modernized version of Forth (dynamically typed, no *very* low level filesystem junk that Forth has).
I've recently started playing with it.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158377</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158809</id>
	<title>some random observations</title>
	<author>bcrowell</author>
	<datestamp>1243789860000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>3</modscore>
	<htmltext><p>
First off, he presents the big chart twice. The second version is meant to compare functional languages with imperative languages, but it's also small enough to fit on my screen, so if you're browsing the article, you might want to look at that one first.
</p><p>
His "obsolete" sector is really more like a special-purpose sector. For instance, Erlang shows up in the obsolete sector, but that's because Erlang wasn't designed to be especially terse or fast. Erlang was designed to be fault-tolerant and automatically parallelizable. Io also ends up looking lousy, but Io also wast designed to be terse and fast; it was designed to be small and simple.
</p><p>
The biggest surprise for me was the high performance of some of the implementations of functional programming languages, even in cases where the particular languages aren't generally known for being implementable in a very efficient way. Two of the best-performing languages are stalin (an implementation of scheme/lisp) and mlton (an implementation of ml). However, as the author notes, it's common to find that if you aren't sufficiently wizardly with fp techniques, you may write fp code that performs much, much worse than the optimal; that was my own experience with ocaml, for instance.
</p><p>
The choice of a linear scale for performance can be a little misleading. For instance, csharp comes out looking like it's not such a great performer, and yet its performance is never worse than the best-performing language by more than a factor of 2 on any task. Typically, if two languages differ by only a factor of 2 in speed, then speed isn't an important factor for choosing between them. The real thing to look out for is that some of the languages seem to have performance that's a gazillion times worse than normal on certain specific tasks.
</p><p>
Many of the languages are hard to find, because they're listed by the names of their implementations. In particular, g95 is an implementation of fortran.
</p></htmltext>
<tokenext>First off , he presents the big chart twice .
The second version is meant to compare functional languages with imperative languages , but it 's also small enough to fit on my screen , so if you 're browsing the article , you might want to look at that one first .
His " obsolete " sector is really more like a special-purpose sector .
For instance , Erlang shows up in the obsolete sector , but that 's because Erlang was n't designed to be especially terse or fast .
Erlang was designed to be fault-tolerant and automatically parallelizable .
Io also ends up looking lousy , but Io also wast designed to be terse and fast ; it was designed to be small and simple .
The biggest surprise for me was the high performance of some of the implementations of functional programming languages , even in cases where the particular languages are n't generally known for being implementable in a very efficient way .
Two of the best-performing languages are stalin ( an implementation of scheme/lisp ) and mlton ( an implementation of ml ) .
However , as the author notes , it 's common to find that if you are n't sufficiently wizardly with fp techniques , you may write fp code that performs much , much worse than the optimal ; that was my own experience with ocaml , for instance .
The choice of a linear scale for performance can be a little misleading .
For instance , csharp comes out looking like it 's not such a great performer , and yet its performance is never worse than the best-performing language by more than a factor of 2 on any task .
Typically , if two languages differ by only a factor of 2 in speed , then speed is n't an important factor for choosing between them .
The real thing to look out for is that some of the languages seem to have performance that 's a gazillion times worse than normal on certain specific tasks .
Many of the languages are hard to find , because they 're listed by the names of their implementations .
In particular , g95 is an implementation of fortran .</tokentext>
<sentencetext>
First off, he presents the big chart twice.
The second version is meant to compare functional languages with imperative languages, but it's also small enough to fit on my screen, so if you're browsing the article, you might want to look at that one first.
His "obsolete" sector is really more like a special-purpose sector.
For instance, Erlang shows up in the obsolete sector, but that's because Erlang wasn't designed to be especially terse or fast.
Erlang was designed to be fault-tolerant and automatically parallelizable.
Io also ends up looking lousy, but Io also wast designed to be terse and fast; it was designed to be small and simple.
The biggest surprise for me was the high performance of some of the implementations of functional programming languages, even in cases where the particular languages aren't generally known for being implementable in a very efficient way.
Two of the best-performing languages are stalin (an implementation of scheme/lisp) and mlton (an implementation of ml).
However, as the author notes, it's common to find that if you aren't sufficiently wizardly with fp techniques, you may write fp code that performs much, much worse than the optimal; that was my own experience with ocaml, for instance.
The choice of a linear scale for performance can be a little misleading.
For instance, csharp comes out looking like it's not such a great performer, and yet its performance is never worse than the best-performing language by more than a factor of 2 on any task.
Typically, if two languages differ by only a factor of 2 in speed, then speed isn't an important factor for choosing between them.
The real thing to look out for is that some of the languages seem to have performance that's a gazillion times worse than normal on certain specific tasks.
Many of the languages are hard to find, because they're listed by the names of their implementations.
In particular, g95 is an implementation of fortran.
</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158889</id>
	<title>Re:C best language out there</title>
	<author>wonkavader</author>
	<datestamp>1243790400000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I like C, too, but one chooses ones language for the task at hand.</p></htmltext>
<tokenext>I like C , too , but one chooses ones language for the task at hand .</tokentext>
<sentencetext>I like C, too, but one chooses ones language for the task at hand.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158413</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28162413</id>
	<title>Re:Forth, the RPN notational programming language</title>
	<author>keyist</author>
	<datestamp>1243775400000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><blockquote><div><p>I can't see getting back to it now, either; lets face it, a huge bonus for any programming language choice is its popularity, so that others will maintain your code, so that you can get help and code fragments with a quick google.</p></div></blockquote><p>

You may want to check out <a href="http://factorcode.org/" title="factorcode.org" rel="nofollow">Factor</a> [factorcode.org].  Both the language and its libraries are actively being developed.  It is concatenative like Forth, with a strong Lisp influence.</p></div>
	</htmltext>
<tokenext>I ca n't see getting back to it now , either ; lets face it , a huge bonus for any programming language choice is its popularity , so that others will maintain your code , so that you can get help and code fragments with a quick google .
You may want to check out Factor [ factorcode.org ] .
Both the language and its libraries are actively being developed .
It is concatenative like Forth , with a strong Lisp influence .</tokentext>
<sentencetext>I can't see getting back to it now, either; lets face it, a huge bonus for any programming language choice is its popularity, so that others will maintain your code, so that you can get help and code fragments with a quick google.
You may want to check out Factor [factorcode.org].
Both the language and its libraries are actively being developed.
It is concatenative like Forth, with a strong Lisp influence.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159419</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159679</id>
	<title>Re:Pet peeve</title>
	<author>Anonymous</author>
	<datestamp>1243796340000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>What you're saying is true, up to a point. The more sophisticated language specifications are more demanding on their implementations - the faster Lisp environment can still only be so fast. To put it another way, a fiendishly clever implementation of Ruby will still not be as fast as a fiendishly clever implementation of C, just because the Ruby runtime is \_expected\_ to do more.</p></htmltext>
<tokenext>What you 're saying is true , up to a point .
The more sophisticated language specifications are more demanding on their implementations - the faster Lisp environment can still only be so fast .
To put it another way , a fiendishly clever implementation of Ruby will still not be as fast as a fiendishly clever implementation of C , just because the Ruby runtime is \ _expected \ _ to do more .</tokentext>
<sentencetext>What you're saying is true, up to a point.
The more sophisticated language specifications are more demanding on their implementations - the faster Lisp environment can still only be so fast.
To put it another way, a fiendishly clever implementation of Ruby will still not be as fast as a fiendishly clever implementation of C, just because the Ruby runtime is \_expected\_ to do more.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158375</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158819</id>
	<title>Re:Scala</title>
	<author>kipton</author>
	<datestamp>1243789920000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>3</modscore>
	<htmltext><p><div class="quote"><p> <tt>I am surprised how they manage to get scala to perform so much worse than pure java.<br></tt></p> </div><p>Scala does generate optimized Java byte code.  Pretty much any Java code can be directly ported to Scala with nearly identical performance.</p><p>The Scala benchmarks perform worsethan Java's, on average, for two main reasons. The first is that some of the tasks have been implemented using higher level code (think memory allocation and closure generation), trading conciseness for performance. The second is that the Scala benchmarks haven't been tuned and tweaked to the extent that the Java ones have.</p><p>Then there are a couple benchmarks where Scala's performance is hugely worse than Java. This seems to be because the Java benchmark was implemented using optimized native libraries (big integers as I recall) or using a better algorithm. Again, Scala could achieve equivalent performance in principle, but someone needs to invest the time to update the benchmark implementations.</p></div>
	</htmltext>
<tokenext>I am surprised how they manage to get scala to perform so much worse than pure java .
Scala does generate optimized Java byte code .
Pretty much any Java code can be directly ported to Scala with nearly identical performance.The Scala benchmarks perform worsethan Java 's , on average , for two main reasons .
The first is that some of the tasks have been implemented using higher level code ( think memory allocation and closure generation ) , trading conciseness for performance .
The second is that the Scala benchmarks have n't been tuned and tweaked to the extent that the Java ones have.Then there are a couple benchmarks where Scala 's performance is hugely worse than Java .
This seems to be because the Java benchmark was implemented using optimized native libraries ( big integers as I recall ) or using a better algorithm .
Again , Scala could achieve equivalent performance in principle , but someone needs to invest the time to update the benchmark implementations .</tokentext>
<sentencetext> I am surprised how they manage to get scala to perform so much worse than pure java.
Scala does generate optimized Java byte code.
Pretty much any Java code can be directly ported to Scala with nearly identical performance.The Scala benchmarks perform worsethan Java's, on average, for two main reasons.
The first is that some of the tasks have been implemented using higher level code (think memory allocation and closure generation), trading conciseness for performance.
The second is that the Scala benchmarks haven't been tuned and tweaked to the extent that the Java ones have.Then there are a couple benchmarks where Scala's performance is hugely worse than Java.
This seems to be because the Java benchmark was implemented using optimized native libraries (big integers as I recall) or using a better algorithm.
Again, Scala could achieve equivalent performance in principle, but someone needs to invest the time to update the benchmark implementations.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158307</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158899</id>
	<title>This is totaly stupid</title>
	<author>FlyingGuy</author>
	<datestamp>1243790460000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>4</modscore>
	<htmltext><p>These sorts of things never fail to to amaze me.</p><p>The verbs, nouns, semantics and such used in a given programming language have <b>nothing</b>, I repeat... <b>NOTHING</b> to do with performance!</p><p>What <b>does</b> have to do with performance is the talent of the compiler / interpreter author, nothing more, nothing less.</p><p> C implements ++ and so forth and so on.  Pascal does not, you have to express it as var<nobr> <wbr></nobr>:= var + x or in some implementations as inc(var) or inc(var,100).  The smart compiler / interpreter author would implement those in the fastest possible way regardless of the particular language.</p><p>The one metric that has real meaning is programmer enjoyment.  Do you prefer terseness over verbosity or something in between.  Does this languages flow amke you truly appreciate working with it.</p><p>The only other real metric that has any true meaning is again the talent of the compiler / interpreter author.  Was the the language parser built so that it can unfold complex statements that are often required to express certain ideas and perform certain operations.  Does the language implement your favorite expression, eg: ++ , or something like that, which again harkens back to programmer enjoyment.</p><p>So what it really leaves us with is, "Do you <b>enjoy</b> using that language?" and only you, the programmer can asnwer that question.</p></htmltext>
<tokenext>These sorts of things never fail to to amaze me.The verbs , nouns , semantics and such used in a given programming language have nothing , I repeat... NOTHING to do with performance ! What does have to do with performance is the talent of the compiler / interpreter author , nothing more , nothing less .
C implements + + and so forth and so on .
Pascal does not , you have to express it as var : = var + x or in some implementations as inc ( var ) or inc ( var,100 ) .
The smart compiler / interpreter author would implement those in the fastest possible way regardless of the particular language.The one metric that has real meaning is programmer enjoyment .
Do you prefer terseness over verbosity or something in between .
Does this languages flow amke you truly appreciate working with it.The only other real metric that has any true meaning is again the talent of the compiler / interpreter author .
Was the the language parser built so that it can unfold complex statements that are often required to express certain ideas and perform certain operations .
Does the language implement your favorite expression , eg : + + , or something like that , which again harkens back to programmer enjoyment.So what it really leaves us with is , " Do you enjoy using that language ?
" and only you , the programmer can asnwer that question .</tokentext>
<sentencetext>These sorts of things never fail to to amaze me.The verbs, nouns, semantics and such used in a given programming language have nothing, I repeat... NOTHING to do with performance!What does have to do with performance is the talent of the compiler / interpreter author, nothing more, nothing less.
C implements ++ and so forth and so on.
Pascal does not, you have to express it as var := var + x or in some implementations as inc(var) or inc(var,100).
The smart compiler / interpreter author would implement those in the fastest possible way regardless of the particular language.The one metric that has real meaning is programmer enjoyment.
Do you prefer terseness over verbosity or something in between.
Does this languages flow amke you truly appreciate working with it.The only other real metric that has any true meaning is again the talent of the compiler / interpreter author.
Was the the language parser built so that it can unfold complex statements that are often required to express certain ideas and perform certain operations.
Does the language implement your favorite expression, eg: ++ , or something like that, which again harkens back to programmer enjoyment.So what it really leaves us with is, "Do you enjoy using that language?
" and only you, the programmer can asnwer that question.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28164935</id>
	<title>Re:What kind of verbosity?</title>
	<author>Anonymous</author>
	<datestamp>1243799160000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Not to be cheeky, but the first example you posted shows the practical advantage of clarity.</p><p>The error is easy to catch, and very obvious.  The mental checks and comparisons needed to throw a flag are minimal.</p><p>for item in list:<br>
&nbsp; &nbsp; &nbsp; &nbsp; print item</p></htmltext>
<tokenext>Not to be cheeky , but the first example you posted shows the practical advantage of clarity.The error is easy to catch , and very obvious .
The mental checks and comparisons needed to throw a flag are minimal.for item in list :         print item</tokentext>
<sentencetext>Not to be cheeky, but the first example you posted shows the practical advantage of clarity.The error is easy to catch, and very obvious.
The mental checks and comparisons needed to throw a flag are minimal.for item in list:
        print item</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28166225</id>
	<title>Re:ccomparison of C and CAS</title>
	<author>Anonymous</author>
	<datestamp>1243860840000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p><div class="quote"><p> <tt>Computer algebra systems are high level programming language. Writing good code does not need<br>documentation. The code itself shows what is done.</tt></p> </div><p>Yes, but why does it do what it does?</p><p>Documentation doesn't say "what" the code does, it says "why" it does so. Why do you want to interpolate those two pictures? Why output them as a GIF and not as a MNG? What are the requirements of your application? What happens if the images are not in the good format? etc.</p><p>I guess you need some doc after all...</p></div>
	</htmltext>
<tokenext>Computer algebra systems are high level programming language .
Writing good code does not needdocumentation .
The code itself shows what is done .
Yes , but why does it do what it does ? Documentation does n't say " what " the code does , it says " why " it does so .
Why do you want to interpolate those two pictures ?
Why output them as a GIF and not as a MNG ?
What are the requirements of your application ?
What happens if the images are not in the good format ?
etc.I guess you need some doc after all.. .</tokentext>
<sentencetext> Computer algebra systems are high level programming language.
Writing good code does not needdocumentation.
The code itself shows what is done.
Yes, but why does it do what it does?Documentation doesn't say "what" the code does, it says "why" it does so.
Why do you want to interpolate those two pictures?
Why output them as a GIF and not as a MNG?
What are the requirements of your application?
What happens if the images are not in the good format?
etc.I guess you need some doc after all...
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158775</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28165575</id>
	<title>Re:What kind of verbosity?</title>
	<author>Anonymous</author>
	<datestamp>1243852620000</datestamp>
	<modclass>Informativ</modclass>
	<modscore>2</modscore>
	<htmltext><b>copy(alist.begin(), alist.end(), std::ostream\_iterator(cout));</b> <br>
Not to mention std::for\_each and std::transform from<nobr> <wbr></nobr>.<br>
Probably just me, but I find your C++ example code slightly unfair.</htmltext>
<tokenext>copy ( alist.begin ( ) , alist.end ( ) , std : : ostream \ _iterator ( cout ) ) ; Not to mention std : : for \ _each and std : : transform from .
Probably just me , but I find your C + + example code slightly unfair .</tokentext>
<sentencetext>copy(alist.begin(), alist.end(), std::ostream\_iterator(cout)); 
Not to mention std::for\_each and std::transform from .
Probably just me, but I find your C++ example code slightly unfair.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28161557</id>
	<title>Re:What kind of verbosity?</title>
	<author>MichaelSmith</author>
	<datestamp>1243767900000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p> <tt>Exactly. As an example:<br>
<br>
for item in list:<br>
print list<br>
</tt></p> </div><p>Is that right?</p></div>
	</htmltext>
<tokenext>Exactly .
As an example : for item in list : print list Is that right ?</tokentext>
<sentencetext> Exactly.
As an example:

for item in list:
print list
 Is that right?
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158219</id>
	<title>what about APL</title>
	<author>Anonymous</author>
	<datestamp>1243784760000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>2</modscore>
	<htmltext><p>APL was faster than C and there has never been a more terse language.</p></htmltext>
<tokenext>APL was faster than C and there has never been a more terse language .</tokentext>
<sentencetext>APL was faster than C and there has never been a more terse language.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28172591</id>
	<title>Garbage collection</title>
	<author>js\_sebastian</author>
	<datestamp>1243846800000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>The only real difference between Java and C execution model (aside from better defined semantics in Java) is that Java does the translation in software, at run-time, taking into account performance characteristics of both the running program and the underlying hardware. </p></div><p>Java is a garbage-collected language.  Garbage collection comes at a cost in performance AND memory. This cost may not be huge in most benchmarks, but there are some benchmarks where it is going to be. Which isn't to say the guys who came up with java were dumb... It so happens that you cannot be safe from pointer errors in a language where the programmer can free memory. <br> <br>
Also java has all that cool introspection/reflection functionality...  The rather weaker but similar run time type information in C++ is a compile time switch, because it causes a significant memory overhead in some cases (when there are many small objects). <br> <br>
Some features have a price. You may want to pay that price (hell, I mostly program in python these days!), but don't delude yourself you're not paying any.</p></div>
	</htmltext>
<tokenext>The only real difference between Java and C execution model ( aside from better defined semantics in Java ) is that Java does the translation in software , at run-time , taking into account performance characteristics of both the running program and the underlying hardware .
Java is a garbage-collected language .
Garbage collection comes at a cost in performance AND memory .
This cost may not be huge in most benchmarks , but there are some benchmarks where it is going to be .
Which is n't to say the guys who came up with java were dumb... It so happens that you can not be safe from pointer errors in a language where the programmer can free memory .
Also java has all that cool introspection/reflection functionality... The rather weaker but similar run time type information in C + + is a compile time switch , because it causes a significant memory overhead in some cases ( when there are many small objects ) .
Some features have a price .
You may want to pay that price ( hell , I mostly program in python these days !
) , but do n't delude yourself you 're not paying any .</tokentext>
<sentencetext>The only real difference between Java and C execution model (aside from better defined semantics in Java) is that Java does the translation in software, at run-time, taking into account performance characteristics of both the running program and the underlying hardware.
Java is a garbage-collected language.
Garbage collection comes at a cost in performance AND memory.
This cost may not be huge in most benchmarks, but there are some benchmarks where it is going to be.
Which isn't to say the guys who came up with java were dumb... It so happens that you cannot be safe from pointer errors in a language where the programmer can free memory.
Also java has all that cool introspection/reflection functionality...  The rather weaker but similar run time type information in C++ is a compile time switch, because it causes a significant memory overhead in some cases (when there are many small objects).
Some features have a price.
You may want to pay that price (hell, I mostly program in python these days!
), but don't delude yourself you're not paying any.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160795</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158731</id>
	<title>Re:Ocaml</title>
	<author>16384</author>
	<datestamp>1243789380000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>3</modscore>
	<htmltext>I don't about the rest of you, but functional languages don't fit my brain, and to me it's not worth the struggle. On the other hand, procedural/OO languages are no trouble at all, and I can learn new ones quickly. I don't understand why anyone would choose lisp, scheme, etc. Maybe they were born with bigger stacks, because when working with functional languages I'll go into stack overflow mode in a jiffy<nobr> <wbr></nobr>:-)</htmltext>
<tokenext>I do n't about the rest of you , but functional languages do n't fit my brain , and to me it 's not worth the struggle .
On the other hand , procedural/OO languages are no trouble at all , and I can learn new ones quickly .
I do n't understand why anyone would choose lisp , scheme , etc .
Maybe they were born with bigger stacks , because when working with functional languages I 'll go into stack overflow mode in a jiffy : - )</tokentext>
<sentencetext>I don't about the rest of you, but functional languages don't fit my brain, and to me it's not worth the struggle.
On the other hand, procedural/OO languages are no trouble at all, and I can learn new ones quickly.
I don't understand why anyone would choose lisp, scheme, etc.
Maybe they were born with bigger stacks, because when working with functional languages I'll go into stack overflow mode in a jiffy :-)</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158575</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28164093</id>
	<title>Paucity of GUI libraries, for one</title>
	<author>duyn</author>
	<datestamp>1243789800000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>Try finding a decent GUI library for Windows, for example. Your choices:
<ul>
<li> <a href="http://wwwfun.kurims.kyoto-u.ac.jp/soft/lsl/lablgtk.html" title="kyoto-u.ac.jp" rel="nofollow">LablGTK</a> [kyoto-u.ac.jp]. GTK on Windows. Yuck.</li><li> <a href="http://caml.inria.fr/pub/docs/manual-ocaml/manual042.html" title="inria.fr" rel="nofollow">LablTk</a> [inria.fr]. Tk is a toy GUI kit.</li><li> <a href="http://ocaml-win32.sourceforge.net/" title="sourceforge.net" rel="nofollow">OCaml-Win32</a> [sourceforge.net]. If you have to ask what's wrong with the win32 API, you've never had to use it in a language other than C.</li><li>Some alpha or out of date binding of <a href="http://plus.kaist.ac.kr/~shoh/ocaml/wxcaml/doc/" title="kaist.ac.kr" rel="nofollow">wxWidgets</a> [kaist.ac.kr] or <a href="http://qt-caml.crapulion.org/trac" title="crapulion.org" rel="nofollow">Qt</a> [crapulion.org] for OCaml.</li></ul><p>OCaml programs aren't shorter than scripting languages, and they're limited to a <a href="http://www.nongnu.org/ocaml-tmk/" title="nongnu.org" rel="nofollow">curses</a> [nongnu.org] interface at best. Together with its speed, OCaml gives off the impression of being a language you'd reach for when you write high performance, low interaction programs---like <a href="http://ocaml.janestreet.com/" title="janestreet.com" rel="nofollow">automated financial trading agents</a> [janestreet.com]. Not many of us do that. And so not many of us use OCaml.</p></htmltext>
<tokenext>Try finding a decent GUI library for Windows , for example .
Your choices : LablGTK [ kyoto-u.ac.jp ] .
GTK on Windows .
Yuck. LablTk [ inria.fr ] .
Tk is a toy GUI kit .
OCaml-Win32 [ sourceforge.net ] .
If you have to ask what 's wrong with the win32 API , you 've never had to use it in a language other than C.Some alpha or out of date binding of wxWidgets [ kaist.ac.kr ] or Qt [ crapulion.org ] for OCaml.OCaml programs are n't shorter than scripting languages , and they 're limited to a curses [ nongnu.org ] interface at best .
Together with its speed , OCaml gives off the impression of being a language you 'd reach for when you write high performance , low interaction programs---like automated financial trading agents [ janestreet.com ] .
Not many of us do that .
And so not many of us use OCaml .</tokentext>
<sentencetext>Try finding a decent GUI library for Windows, for example.
Your choices:

 LablGTK [kyoto-u.ac.jp].
GTK on Windows.
Yuck. LablTk [inria.fr].
Tk is a toy GUI kit.
OCaml-Win32 [sourceforge.net].
If you have to ask what's wrong with the win32 API, you've never had to use it in a language other than C.Some alpha or out of date binding of wxWidgets [kaist.ac.kr] or Qt [crapulion.org] for OCaml.OCaml programs aren't shorter than scripting languages, and they're limited to a curses [nongnu.org] interface at best.
Together with its speed, OCaml gives off the impression of being a language you'd reach for when you write high performance, low interaction programs---like automated financial trading agents [janestreet.com].
Not many of us do that.
And so not many of us use OCaml.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158575</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159289</id>
	<title>Lua?</title>
	<author>Anonymous</author>
	<datestamp>1243793700000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>I have to say I was really surprised by Lua, and especially LuaJIT.</p><p>It has me wondering why it's not used more often. It seems like a really simple, clean language, with a fast implementation.</p><p>Why isn't it used as often as say, Python, Perl, or Ruby?</p><p>I know it's been used in game scripting, but why not elsewhere?</p><p>I know very little about Lua--I hadn't paid much attention to it now, but are there people who have considered using it over another traditional scripting language? Why did they adopt it or not adopt it? Lua seems very nice.</p></htmltext>
<tokenext>I have to say I was really surprised by Lua , and especially LuaJIT.It has me wondering why it 's not used more often .
It seems like a really simple , clean language , with a fast implementation.Why is n't it used as often as say , Python , Perl , or Ruby ? I know it 's been used in game scripting , but why not elsewhere ? I know very little about Lua--I had n't paid much attention to it now , but are there people who have considered using it over another traditional scripting language ?
Why did they adopt it or not adopt it ?
Lua seems very nice .</tokentext>
<sentencetext>I have to say I was really surprised by Lua, and especially LuaJIT.It has me wondering why it's not used more often.
It seems like a really simple, clean language, with a fast implementation.Why isn't it used as often as say, Python, Perl, or Ruby?I know it's been used in game scripting, but why not elsewhere?I know very little about Lua--I hadn't paid much attention to it now, but are there people who have considered using it over another traditional scripting language?
Why did they adopt it or not adopt it?
Lua seems very nice.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158689</id>
	<title>Ruby</title>
	<author>Anonymous</author>
	<datestamp>1243788840000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>4</modscore>
	<htmltext><p><div class="quote"><p>On the plus side, both versions of Python can claim many of the smallest programs in the collection. Ruby (8, 1) might also compete for titles, but unfortunately its performance is so bad its star falls off the performance chart.</p></div><p>Then why the fuck is the Ruby community hyping it so much, and drawing nieve young developers in to a trap?</p><p>Not flamebait.</p><p>Why can't they make a language, or extend a language like Ruby, such that one can program it as a scripting language, but then add verbosity optionally (i.e. declaring the data types and their sizes, private / static etc. &amp; whatever the hell makes a program light weight and fast) optionally? It's my hope that if I stick with Ruby one day it I won't be forced to learn Python because performance won't be "Ruby's big issue" in every discussion, but really, that is *just* a hope. I hope this isn't a mistake.</p></div>
	</htmltext>
<tokenext>On the plus side , both versions of Python can claim many of the smallest programs in the collection .
Ruby ( 8 , 1 ) might also compete for titles , but unfortunately its performance is so bad its star falls off the performance chart.Then why the fuck is the Ruby community hyping it so much , and drawing nieve young developers in to a trap ? Not flamebait.Why ca n't they make a language , or extend a language like Ruby , such that one can program it as a scripting language , but then add verbosity optionally ( i.e .
declaring the data types and their sizes , private / static etc .
&amp; whatever the hell makes a program light weight and fast ) optionally ?
It 's my hope that if I stick with Ruby one day it I wo n't be forced to learn Python because performance wo n't be " Ruby 's big issue " in every discussion , but really , that is * just * a hope .
I hope this is n't a mistake .</tokentext>
<sentencetext>On the plus side, both versions of Python can claim many of the smallest programs in the collection.
Ruby (8, 1) might also compete for titles, but unfortunately its performance is so bad its star falls off the performance chart.Then why the fuck is the Ruby community hyping it so much, and drawing nieve young developers in to a trap?Not flamebait.Why can't they make a language, or extend a language like Ruby, such that one can program it as a scripting language, but then add verbosity optionally (i.e.
declaring the data types and their sizes, private / static etc.
&amp; whatever the hell makes a program light weight and fast) optionally?
It's my hope that if I stick with Ruby one day it I won't be forced to learn Python because performance won't be "Ruby's big issue" in every discussion, but really, that is *just* a hope.
I hope this isn't a mistake.
	</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158335</id>
	<title>The perfect language exists, you ignorant clod!</title>
	<author>Anonymous</author>
	<datestamp>1243785960000</datestamp>
	<modclass>Funny</modclass>
	<modscore>5</modscore>
	<htmltext><p><div class="quote"><p>And finally, in the bottom left corner you would find probably nothing, since this is the space of the ideal language, the one which is at the same time fast and short and a joy to use."</p></div><p>Plain ASCII.  The shorter and faster it is, the more joy it is to use.
</p><p>
What can compare to the joy and speed of, for example, the command "Go fuck yourself!"
</p><p>
Even shorter and faster syntax: the command "F.U.!"
</p><p>
And for conciseness of comments - "SHIT!" and "oops!" and "WTF???"
</p><p>
Looping constructs: "Sit on it and rotate!"
</p><p>
If-else constructs: "Dat so? F.U. 2!"
</p><p>
foreach: "You, your mamma, and the horse you rode into town on!"
</p><p>
Exit statements : Just fuck off!"
</p><p>
c-style assertions: "Eat shit and DIE!"
</p><p>
#defines: "#define YOU One dumb motherfucka"
</p><p>
conditional #includes "#ifdef YO\_MAMMA"
</p><p>
real-time peremption: "I OWN you, beotch!"
</p></div>
	</htmltext>
<tokenext>And finally , in the bottom left corner you would find probably nothing , since this is the space of the ideal language , the one which is at the same time fast and short and a joy to use .
" Plain ASCII .
The shorter and faster it is , the more joy it is to use .
What can compare to the joy and speed of , for example , the command " Go fuck yourself !
" Even shorter and faster syntax : the command " F.U. !
" And for conciseness of comments - " SHIT !
" and " oops !
" and " WTF ? ? ?
" Looping constructs : " Sit on it and rotate !
" If-else constructs : " Dat so ?
F.U. 2 !
" foreach : " You , your mamma , and the horse you rode into town on !
" Exit statements : Just fuck off !
" c-style assertions : " Eat shit and DIE !
" # defines : " # define YOU One dumb motherfucka " conditional # includes " # ifdef YO \ _MAMMA " real-time peremption : " I OWN you , beotch !
"</tokentext>
<sentencetext>And finally, in the bottom left corner you would find probably nothing, since this is the space of the ideal language, the one which is at the same time fast and short and a joy to use.
"Plain ASCII.
The shorter and faster it is, the more joy it is to use.
What can compare to the joy and speed of, for example, the command "Go fuck yourself!
"

Even shorter and faster syntax: the command "F.U.!
"

And for conciseness of comments - "SHIT!
" and "oops!
" and "WTF???
"

Looping constructs: "Sit on it and rotate!
"

If-else constructs: "Dat so?
F.U. 2!
"

foreach: "You, your mamma, and the horse you rode into town on!
"

Exit statements : Just fuck off!
"

c-style assertions: "Eat shit and DIE!
"

#defines: "#define YOU One dumb motherfucka"

conditional #includes "#ifdef YO\_MAMMA"

real-time peremption: "I OWN you, beotch!
"

	</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158755</id>
	<title>Ada</title>
	<author>danwesnor</author>
	<datestamp>1243789440000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>Where's Ada?</htmltext>
<tokenext>Where 's Ada ?</tokentext>
<sentencetext>Where's Ada?</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159839</id>
	<title>Re:Where are the real lanaguages???</title>
	<author>StormReaver</author>
	<datestamp>1243797660000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>&gt; Where Cobol and RPG, the languages that run business?</p><p>I saw them being led into the alleyway.  If we're lucky, we'll hear gunshots soon.</p></htmltext>
<tokenext>&gt; Where Cobol and RPG , the languages that run business ? I saw them being led into the alleyway .
If we 're lucky , we 'll hear gunshots soon .</tokentext>
<sentencetext>&gt; Where Cobol and RPG, the languages that run business?I saw them being led into the alleyway.
If we're lucky, we'll hear gunshots soon.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158405</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158901</id>
	<title>Re:Forth, the RPN notational programming language</title>
	<author>rubycodez</author>
	<datestamp>1243790520000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>even though it can generate code that runs faster than compiled C on certain platforms, can it really be used for truly huge projects?  is there a modern word processor or DBMS or CADD system written in FORTH?</p></htmltext>
<tokenext>even though it can generate code that runs faster than compiled C on certain platforms , can it really be used for truly huge projects ?
is there a modern word processor or DBMS or CADD system written in FORTH ?</tokentext>
<sentencetext>even though it can generate code that runs faster than compiled C on certain platforms, can it really be used for truly huge projects?
is there a modern word processor or DBMS or CADD system written in FORTH?</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158377</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160523</id>
	<title>Re:Where are the old standards?</title>
	<author>HiThere</author>
	<datestamp>1243802880000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>cmucl is a Common Lisp.  And I think he's got a Scheme dialect there too.</p><p>What's really strange is that gcc is considered as ONE compiler.</p></htmltext>
<tokenext>cmucl is a Common Lisp .
And I think he 's got a Scheme dialect there too.What 's really strange is that gcc is considered as ONE compiler .</tokentext>
<sentencetext>cmucl is a Common Lisp.
And I think he's got a Scheme dialect there too.What's really strange is that gcc is considered as ONE compiler.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158369</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28163519</id>
	<title>Re:Ada</title>
	<author>rally2xs</author>
	<datestamp>1243784640000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>I think its the one labeled "gnat."</htmltext>
<tokenext>I think its the one labeled " gnat .
"</tokentext>
<sentencetext>I think its the one labeled "gnat.
"</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158755</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158939</id>
	<title>Re:The perfect language exists, you ignorant clod!</title>
	<author>BorgCopyeditor</author>
	<datestamp>1243790820000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><i>Looping constructs: "Sit on it and rotate!"</i></p><p>Or the syntactic sugar shorthand: "Sit and spin!"</p></htmltext>
<tokenext>Looping constructs : " Sit on it and rotate !
" Or the syntactic sugar shorthand : " Sit and spin !
"</tokentext>
<sentencetext>Looping constructs: "Sit on it and rotate!
"Or the syntactic sugar shorthand: "Sit and spin!
"</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158335</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28174401</id>
	<title>Re:what about APL</title>
	<author>DavidHumus</author>
	<datestamp>1243853520000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>2</modscore>
	<htmltext><p>Some of us have submitted programs in APL, or its younger sibling J, to the shootout (see <a href="http://www.mail-archive.com/general@jsoftware.com/msg02859.html" title="mail-archive.com" rel="nofollow">http://www.mail-archive.com/general@jsoftware.com/msg02859.html</a> [mail-archive.com]).  However, since the rules of the shootout specify the algorithm you have to use, you end up writing C programs in APL or J which is no way to take advantage of the power and expressiveness of these languages.</p><p>It's like taking part in a poetry contest where you're only allowed baby-talk.</p></htmltext>
<tokenext>Some of us have submitted programs in APL , or its younger sibling J , to the shootout ( see http : //www.mail-archive.com/general @ jsoftware.com/msg02859.html [ mail-archive.com ] ) .
However , since the rules of the shootout specify the algorithm you have to use , you end up writing C programs in APL or J which is no way to take advantage of the power and expressiveness of these languages.It 's like taking part in a poetry contest where you 're only allowed baby-talk .</tokentext>
<sentencetext>Some of us have submitted programs in APL, or its younger sibling J, to the shootout (see http://www.mail-archive.com/general@jsoftware.com/msg02859.html [mail-archive.com]).
However, since the rules of the shootout specify the algorithm you have to use, you end up writing C programs in APL or J which is no way to take advantage of the power and expressiveness of these languages.It's like taking part in a poetry contest where you're only allowed baby-talk.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158747</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159385</id>
	<title>Re:Forth, the RPN notational programming language</title>
	<author>Richard W.M. Jones</author>
	<datestamp>1243794360000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>3</modscore>
	<htmltext>I wrote a little "literate" FORTH tutorial if any readers of the above comment
are interested in it: <a href="http://www.annexia.org/forth" title="annexia.org">jonesforth</a> [annexia.org].</htmltext>
<tokenext>I wrote a little " literate " FORTH tutorial if any readers of the above comment are interested in it : jonesforth [ annexia.org ] .</tokentext>
<sentencetext>I wrote a little "literate" FORTH tutorial if any readers of the above comment
are interested in it: jonesforth [annexia.org].</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158377</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159155</id>
	<title>Re:C best language out there</title>
	<author>mdmkolbe</author>
	<datestamp>1243792620000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>3</modscore>
	<htmltext><p>Ha ha.  Good joke.  You've forgotten the most important feature "needed in a great programming lang": <a href="http://en.wikipedia.org/wiki/Higher-order\_function" title="wikipedia.org">higher-order</a> [wikipedia.org] and <a href="http://en.wikipedia.org/wiki/First-class\_function" title="wikipedia.org">first-class</a> [wikipedia.org] functions with proper <a href="http://en.wikipedia.org/wiki/Closure\_(computer\_science)" title="wikipedia.org">closures</a> [wikipedia.org].  Oh wait, C doesn't have that.</p><p>Any truly great statically typed language will also have at least <a href="http://en.wikipedia.org/wiki/Algebraic\_data\_type" title="wikipedia.org">algebraic data types</a> [wikipedia.org], <a href="http://en.wikipedia.org/wiki/Polymorphism\_(computer\_science)" title="wikipedia.org">parametric polymorphism</a> [wikipedia.org] (even C++ only has ad-hoc polymorphism), type constructors and functions, maybe even a Turing complete type system (heh).  C doesn't have any of those.</p><p>Even aside from types, great languages should include <a href="http://en.wikipedia.org/wiki/Tail\_call" title="wikipedia.org">tail-call optimization</a> [wikipedia.org], <a href="http://en.wikipedia.org/wiki/Pattern\_matching" title="wikipedia.org">pattern matching</a> [wikipedia.org] and <a href="http://en.wikipedia.org/wiki/Hygienic\_macros" title="wikipedia.org">hygienic macros</a> [wikipedia.org] (CPP macros are a bad joke).</p><p>Now don't get me wrong.  C is a great portable assembly language.  It's close to the metal, widely known and easy to read.  But as far as programming languages go, C feature poor.</p></htmltext>
<tokenext>Ha ha .
Good joke .
You 've forgotten the most important feature " needed in a great programming lang " : higher-order [ wikipedia.org ] and first-class [ wikipedia.org ] functions with proper closures [ wikipedia.org ] .
Oh wait , C does n't have that.Any truly great statically typed language will also have at least algebraic data types [ wikipedia.org ] , parametric polymorphism [ wikipedia.org ] ( even C + + only has ad-hoc polymorphism ) , type constructors and functions , maybe even a Turing complete type system ( heh ) .
C does n't have any of those.Even aside from types , great languages should include tail-call optimization [ wikipedia.org ] , pattern matching [ wikipedia.org ] and hygienic macros [ wikipedia.org ] ( CPP macros are a bad joke ) .Now do n't get me wrong .
C is a great portable assembly language .
It 's close to the metal , widely known and easy to read .
But as far as programming languages go , C feature poor .</tokentext>
<sentencetext>Ha ha.
Good joke.
You've forgotten the most important feature "needed in a great programming lang": higher-order [wikipedia.org] and first-class [wikipedia.org] functions with proper closures [wikipedia.org].
Oh wait, C doesn't have that.Any truly great statically typed language will also have at least algebraic data types [wikipedia.org], parametric polymorphism [wikipedia.org] (even C++ only has ad-hoc polymorphism), type constructors and functions, maybe even a Turing complete type system (heh).
C doesn't have any of those.Even aside from types, great languages should include tail-call optimization [wikipedia.org], pattern matching [wikipedia.org] and hygienic macros [wikipedia.org] (CPP macros are a bad joke).Now don't get me wrong.
C is a great portable assembly language.
It's close to the metal, widely known and easy to read.
But as far as programming languages go, C feature poor.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158413</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158787</id>
	<title>Where's D?</title>
	<author>Twinbee</author>
	<datestamp>1243789680000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I wish D was one of the contenders. It'd be shown pretty far to the lower left I'm betting.</p></htmltext>
<tokenext>I wish D was one of the contenders .
It 'd be shown pretty far to the lower left I 'm betting .</tokentext>
<sentencetext>I wish D was one of the contenders.
It'd be shown pretty far to the lower left I'm betting.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159631</id>
	<title>Re:C best language out there</title>
	<author>Anonymous</author>
	<datestamp>1243796040000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>The wikipedia article that you referenced for parametric polymorphism contradicts your claim that C++ only has ad-hoc polymorphism. The higher-order article also points out that C supports one type of higher-order function, a function that takes another function as an argument. First-class functions cannot be implemented without reflection or some ability to compile code at runtime (JavaScript's eval for example); not having them in a natively compiled language like C makes sense.<br>
&nbsp; <br>Calling C feature poor is the same as calling "the metal" feature poor.</p></htmltext>
<tokenext>The wikipedia article that you referenced for parametric polymorphism contradicts your claim that C + + only has ad-hoc polymorphism .
The higher-order article also points out that C supports one type of higher-order function , a function that takes another function as an argument .
First-class functions can not be implemented without reflection or some ability to compile code at runtime ( JavaScript 's eval for example ) ; not having them in a natively compiled language like C makes sense .
  Calling C feature poor is the same as calling " the metal " feature poor .</tokentext>
<sentencetext>The wikipedia article that you referenced for parametric polymorphism contradicts your claim that C++ only has ad-hoc polymorphism.
The higher-order article also points out that C supports one type of higher-order function, a function that takes another function as an argument.
First-class functions cannot be implemented without reflection or some ability to compile code at runtime (JavaScript's eval for example); not having them in a natively compiled language like C makes sense.
  Calling C feature poor is the same as calling "the metal" feature poor.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159155</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159005</id>
	<title>Logarithmic x axis</title>
	<author>Twinbee</author>
	<datestamp>1243791360000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>These graphs are great, but it would be nice to see the X axis expressed logarithmically for a greater range of time tests.</p></htmltext>
<tokenext>These graphs are great , but it would be nice to see the X axis expressed logarithmically for a greater range of time tests .</tokentext>
<sentencetext>These graphs are great, but it would be nice to see the X axis expressed logarithmically for a greater range of time tests.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28165075</id>
	<title>Re:This is totaly stupid</title>
	<author>grumbel</author>
	<datestamp>1243887960000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>NOTHING to do with performance!</p></div><p>That is only true when it comes to syntactic sugar, its not true when it comes to semantics. For example when I write:</p><blockquote><div><p> <tt>for(int i = 0; i &lt; 100; ++i)<br>
&nbsp; lst[i] = do\_math(lst[i]);</tt></p></div> </blockquote><p>I don't just tell the compiler what I want to do, but I also say how I want it to be done. The variable i for example has nothing to do with my problem and neither has the forced sequential evaluation. And there isn't an easy way to figure out if do\_math() has side effects when it is hidden in some external library either. A compiler will have a much harder time figuring out my intend then in a language that allows me to express what I want to do, instead of how:</p><blockquote><div><p> <tt>map do\_math lst</tt></p></div> </blockquote><p>Here the compiler knows instantly that I don't care about the order of evaluation and it also knows that do\_math doesn't have side effects because its a function, so it can split up the task across multiple CPUs without a problem.</p></div>
	</htmltext>
<tokenext>NOTHING to do with performance ! That is only true when it comes to syntactic sugar , its not true when it comes to semantics .
For example when I write : for ( int i = 0 ; i   lst [ i ] = do \ _math ( lst [ i ] ) ; I do n't just tell the compiler what I want to do , but I also say how I want it to be done .
The variable i for example has nothing to do with my problem and neither has the forced sequential evaluation .
And there is n't an easy way to figure out if do \ _math ( ) has side effects when it is hidden in some external library either .
A compiler will have a much harder time figuring out my intend then in a language that allows me to express what I want to do , instead of how : map do \ _math lst Here the compiler knows instantly that I do n't care about the order of evaluation and it also knows that do \ _math does n't have side effects because its a function , so it can split up the task across multiple CPUs without a problem .</tokentext>
<sentencetext>NOTHING to do with performance!That is only true when it comes to syntactic sugar, its not true when it comes to semantics.
For example when I write: for(int i = 0; i 
  lst[i] = do\_math(lst[i]); I don't just tell the compiler what I want to do, but I also say how I want it to be done.
The variable i for example has nothing to do with my problem and neither has the forced sequential evaluation.
And there isn't an easy way to figure out if do\_math() has side effects when it is hidden in some external library either.
A compiler will have a much harder time figuring out my intend then in a language that allows me to express what I want to do, instead of how: map do\_math lst Here the compiler knows instantly that I don't care about the order of evaluation and it also knows that do\_math doesn't have side effects because its a function, so it can split up the task across multiple CPUs without a problem.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158899</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159073</id>
	<title>Re:what about APL</title>
	<author>Twinbee</author>
	<datestamp>1243792020000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Is it less verbose in line or character count?</p><p>Or on a word/symbol level, which I would think is more important...</p></htmltext>
<tokenext>Is it less verbose in line or character count ? Or on a word/symbol level , which I would think is more important.. .</tokentext>
<sentencetext>Is it less verbose in line or character count?Or on a word/symbol level, which I would think is more important...</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158219</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158657</id>
	<title>Re:C best language out there</title>
	<author>Anonymous</author>
	<datestamp>1243788600000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>"C is available on all modern platforms, C has the best compiler of all time on it's side GCC"</p><p>Since when is GCC the best compiler of all time? I'm no expert but I've seen a lot of people complain about GCC, and I'm sure I've read that Intel has a much faster C Compiler.</p></htmltext>
<tokenext>" C is available on all modern platforms , C has the best compiler of all time on it 's side GCC " Since when is GCC the best compiler of all time ?
I 'm no expert but I 've seen a lot of people complain about GCC , and I 'm sure I 've read that Intel has a much faster C Compiler .</tokentext>
<sentencetext>"C is available on all modern platforms, C has the best compiler of all time on it's side GCC"Since when is GCC the best compiler of all time?
I'm no expert but I've seen a lot of people complain about GCC, and I'm sure I've read that Intel has a much faster C Compiler.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158413</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28170151</id>
	<title>Re:C best language out there</title>
	<author>Anonymous</author>
	<datestamp>1243880460000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>So is every program written in such a language going to include a JIT compiler?  None of those features you describe are going to be available in any language that has performance comparable to C.</p></htmltext>
<tokenext>So is every program written in such a language going to include a JIT compiler ?
None of those features you describe are going to be available in any language that has performance comparable to C .</tokentext>
<sentencetext>So is every program written in such a language going to include a JIT compiler?
None of those features you describe are going to be available in any language that has performance comparable to C.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159155</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28162379</id>
	<title>Re:What kind of verbosity?</title>
	<author>ydrol</author>
	<datestamp>1243775100000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>2</modscore>
	<htmltext><p>for(object o in list) {<br>
&nbsp; &nbsp; Item item = (Item) o;<br>
&nbsp; &nbsp; System.Out.Println(item);<br>}</p><p>What language is this? If its Java maybe</p><p>for(Item o : list) {<br>
&nbsp; &nbsp; System.Out.Println(o);<br>}</p><p>Although java 1.4 would have been more painful..</p><p><a href="http://leepoint.net/notes-java/flow/loops/foreach.html" title="leepoint.net">http://leepoint.net/notes-java/flow/loops/foreach.html</a> [leepoint.net]</p><p>Also I guess there are times when strong typing is considered expressive and when it is considered overly verbose.<br>In a large application, weak typing sometimes is a PITA, in a short script it is lovely.</p></htmltext>
<tokenext>for ( object o in list ) {     Item item = ( Item ) o ;     System.Out.Println ( item ) ; } What language is this ?
If its Java maybefor ( Item o : list ) {     System.Out.Println ( o ) ; } Although java 1.4 would have been more painful..http : //leepoint.net/notes-java/flow/loops/foreach.html [ leepoint.net ] Also I guess there are times when strong typing is considered expressive and when it is considered overly verbose.In a large application , weak typing sometimes is a PITA , in a short script it is lovely .</tokentext>
<sentencetext>for(object o in list) {
    Item item = (Item) o;
    System.Out.Println(item);}What language is this?
If its Java maybefor(Item o : list) {
    System.Out.Println(o);}Although java 1.4 would have been more painful..http://leepoint.net/notes-java/flow/loops/foreach.html [leepoint.net]Also I guess there are times when strong typing is considered expressive and when it is considered overly verbose.In a large application, weak typing sometimes is a PITA, in a short script it is lovely.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158413</id>
	<title>C best language out there</title>
	<author>Anonymous</author>
	<datestamp>1243786620000</datestamp>
	<modclass>Offtopic</modclass>
	<modscore>-1</modscore>
	<htmltext>Personally I'd pick C as being the best all around programming language to work with, and that is C NOT C++.
C has all the features needed in a great programming lang (PL) .   You can interface close enough to the hardware for complete control, you can inline assembler right into the code.   The preprocessing feature work awesome, using macros to replace short functions, even the library's a user has access to.  The syntax is great to work with, it's a quick to temp up PL, you can really make a functional program in less then 2 min that has meaning, with out comments mind you.
<br>
<br>
C is available on all modern platforms, C has the best compiler of all time on it's side GCC,   The GTK / Gnome environment is even based off C.   C has everything needed in PL to make it the number 1 pick of all time.  Needless to say it's also stood the test of time.</htmltext>
<tokenext>Personally I 'd pick C as being the best all around programming language to work with , and that is C NOT C + + .
C has all the features needed in a great programming lang ( PL ) .
You can interface close enough to the hardware for complete control , you can inline assembler right into the code .
The preprocessing feature work awesome , using macros to replace short functions , even the library 's a user has access to .
The syntax is great to work with , it 's a quick to temp up PL , you can really make a functional program in less then 2 min that has meaning , with out comments mind you .
C is available on all modern platforms , C has the best compiler of all time on it 's side GCC , The GTK / Gnome environment is even based off C. C has everything needed in PL to make it the number 1 pick of all time .
Needless to say it 's also stood the test of time .</tokentext>
<sentencetext>Personally I'd pick C as being the best all around programming language to work with, and that is C NOT C++.
C has all the features needed in a great programming lang (PL) .
You can interface close enough to the hardware for complete control, you can inline assembler right into the code.
The preprocessing feature work awesome, using macros to replace short functions, even the library's a user has access to.
The syntax is great to work with, it's a quick to temp up PL, you can really make a functional program in less then 2 min that has meaning, with out comments mind you.
C is available on all modern platforms, C has the best compiler of all time on it's side GCC,   The GTK / Gnome environment is even based off C.   C has everything needed in PL to make it the number 1 pick of all time.
Needless to say it's also stood the test of time.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158471</id>
	<title>Re:Why is Verbosity Bad?</title>
	<author>maxume</author>
	<datestamp>1243786980000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Counting characters is a lot less interesting than counting symbols. Of course, a language with too many symbols will be more obscure than one that makes somewhat repetitive use of a smaller set of symbols, so the whole thing is still pretty subjective.</p></htmltext>
<tokenext>Counting characters is a lot less interesting than counting symbols .
Of course , a language with too many symbols will be more obscure than one that makes somewhat repetitive use of a smaller set of symbols , so the whole thing is still pretty subjective .</tokentext>
<sentencetext>Counting characters is a lot less interesting than counting symbols.
Of course, a language with too many symbols will be more obscure than one that makes somewhat repetitive use of a smaller set of symbols, so the whole thing is still pretty subjective.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158223</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28188203</id>
	<title>Re:Ruby</title>
	<author>GWBasic</author>
	<datestamp>1243938660000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>Then why the fuck is the Ruby community hyping it so much, and drawing nieve young developers in to a trap?</p></div><p>Ruby on Rails seems to be intended for rapid prototyping; and web applications that don't need to scale.</p><p>In my career, I've worked on plenty of applications that only need to handle a few concurrent users.  The data processing is so valuable that the UI only needs to be good enough to enable a few users to process terrabytes of data that come from heavy machinery.  In these situations, Ruby on Rails is much more appropriate then finely-tuned ASP, C#, Java, C++, ect, ect, because the web server will never break a sweat.</p></div>
	</htmltext>
<tokenext>Then why the fuck is the Ruby community hyping it so much , and drawing nieve young developers in to a trap ? Ruby on Rails seems to be intended for rapid prototyping ; and web applications that do n't need to scale.In my career , I 've worked on plenty of applications that only need to handle a few concurrent users .
The data processing is so valuable that the UI only needs to be good enough to enable a few users to process terrabytes of data that come from heavy machinery .
In these situations , Ruby on Rails is much more appropriate then finely-tuned ASP , C # , Java , C + + , ect , ect , because the web server will never break a sweat .</tokentext>
<sentencetext>Then why the fuck is the Ruby community hyping it so much, and drawing nieve young developers in to a trap?Ruby on Rails seems to be intended for rapid prototyping; and web applications that don't need to scale.In my career, I've worked on plenty of applications that only need to handle a few concurrent users.
The data processing is so valuable that the UI only needs to be good enough to enable a few users to process terrabytes of data that come from heavy machinery.
In these situations, Ruby on Rails is much more appropriate then finely-tuned ASP, C#, Java, C++, ect, ect, because the web server will never break a sweat.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158689</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160617</id>
	<title>These benchmarks suck</title>
	<author>coppro</author>
	<datestamp>1243803420000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>2</modscore>
	<htmltext>Okay, there's many problems with the benchmarks here, including in the labeling.

<ul>
<li>The uses of each language aren't analyzed. I've never encountered a desktop application written in Perl, nor have I ever seen a C++ web framework (I'm sure both exist, but they aren't common)</li><li>Dependability isn't analyzed. The title specifically says 'dependability'. I can excuse them because well-written Erlang smokes the competition in terms of reliability (Some Erlang-based servers have been running with 100\% uptime for years).</li><li>This is not a comparison of multiple programming languages. It's a comparison of a haphazard set of environments. For instance, C and C++ are not distinguished, but the various compilers are. On the other hand, C# and F# are grouped the same, even though they operate in the same VM, with the same JIT optimizer, and so on (and Mono, on the other hand, is nowhere to be found.</li></ul><p>

I'm sure there are others, but I have work to do.</p></htmltext>
<tokenext>Okay , there 's many problems with the benchmarks here , including in the labeling .
The uses of each language are n't analyzed .
I 've never encountered a desktop application written in Perl , nor have I ever seen a C + + web framework ( I 'm sure both exist , but they are n't common ) Dependability is n't analyzed .
The title specifically says 'dependability' .
I can excuse them because well-written Erlang smokes the competition in terms of reliability ( Some Erlang-based servers have been running with 100 \ % uptime for years ) .This is not a comparison of multiple programming languages .
It 's a comparison of a haphazard set of environments .
For instance , C and C + + are not distinguished , but the various compilers are .
On the other hand , C # and F # are grouped the same , even though they operate in the same VM , with the same JIT optimizer , and so on ( and Mono , on the other hand , is nowhere to be found .
I 'm sure there are others , but I have work to do .</tokentext>
<sentencetext>Okay, there's many problems with the benchmarks here, including in the labeling.
The uses of each language aren't analyzed.
I've never encountered a desktop application written in Perl, nor have I ever seen a C++ web framework (I'm sure both exist, but they aren't common)Dependability isn't analyzed.
The title specifically says 'dependability'.
I can excuse them because well-written Erlang smokes the competition in terms of reliability (Some Erlang-based servers have been running with 100\% uptime for years).This is not a comparison of multiple programming languages.
It's a comparison of a haphazard set of environments.
For instance, C and C++ are not distinguished, but the various compilers are.
On the other hand, C# and F# are grouped the same, even though they operate in the same VM, with the same JIT optimizer, and so on (and Mono, on the other hand, is nowhere to be found.
I'm sure there are others, but I have work to do.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160521</id>
	<title>Re:This is totaly stupid</title>
	<author>shutdown -p now</author>
	<datestamp>1243802880000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>The verbs, nouns, semantics and such used in a given programming language have nothing, I repeat... NOTHING to do with performance!</p><p>What does have to do with performance is the talent of the compiler / interpreter author, nothing more, nothing less.</p><p>C implements ++ and so forth and so on. Pascal does not, you have to express it as var<nobr> <wbr></nobr>:= var + x or in some implementations as inc(var) or inc(var,100). The smart compiler / interpreter author would implement those in the fastest possible way regardless of the particular language.</p></div><p>This is all wishful thinking. In practice, language design does have very serious performance implications.</p><p>Here's one simple example. Java doesn't have user-defined structural value types (i.e. types with structural equality and no inherent referential identity), only reference types. C# has both (structs vs classes). Value types are generally more efficient because the compiler doesn't always need to heap-allocate them, doesn't have to guarantee meaningful referential identity comparison for them, and doesn't need to support "null" as a special value.</p><p>Now, in theory, an optimizing Java JIT can analyze how a type is actually used in the code, and deduce from its usage that it is actually treated as a value type, and then optimize it accordingly. However, this requires some quite advanced escape analysis technques - so much so that, IIRC, only the upcoming major Java release actually has this feature. Meanwhile, all C# implementations just do what the programmer told them (by identifying the type as "struct" = value type), enjoying the performance increase. It has been estimated that C# structs are one of the most important factors of why Java doesn't overtake C# performance-wise (because otherwise Java has a better GC and JIT).</p><p>To sum it up: yes, in theory, it is possible to make a perfect whole-program optimizing compiler that can do every trick imaginable, from ideal type inference to escape analysis. In practice, we're still about as far from that as we are from working, production-quality fusion power plants.</p></div>
	</htmltext>
<tokenext>The verbs , nouns , semantics and such used in a given programming language have nothing , I repeat... NOTHING to do with performance ! What does have to do with performance is the talent of the compiler / interpreter author , nothing more , nothing less.C implements + + and so forth and so on .
Pascal does not , you have to express it as var : = var + x or in some implementations as inc ( var ) or inc ( var,100 ) .
The smart compiler / interpreter author would implement those in the fastest possible way regardless of the particular language.This is all wishful thinking .
In practice , language design does have very serious performance implications.Here 's one simple example .
Java does n't have user-defined structural value types ( i.e .
types with structural equality and no inherent referential identity ) , only reference types .
C # has both ( structs vs classes ) .
Value types are generally more efficient because the compiler does n't always need to heap-allocate them , does n't have to guarantee meaningful referential identity comparison for them , and does n't need to support " null " as a special value.Now , in theory , an optimizing Java JIT can analyze how a type is actually used in the code , and deduce from its usage that it is actually treated as a value type , and then optimize it accordingly .
However , this requires some quite advanced escape analysis technques - so much so that , IIRC , only the upcoming major Java release actually has this feature .
Meanwhile , all C # implementations just do what the programmer told them ( by identifying the type as " struct " = value type ) , enjoying the performance increase .
It has been estimated that C # structs are one of the most important factors of why Java does n't overtake C # performance-wise ( because otherwise Java has a better GC and JIT ) .To sum it up : yes , in theory , it is possible to make a perfect whole-program optimizing compiler that can do every trick imaginable , from ideal type inference to escape analysis .
In practice , we 're still about as far from that as we are from working , production-quality fusion power plants .</tokentext>
<sentencetext>The verbs, nouns, semantics and such used in a given programming language have nothing, I repeat... NOTHING to do with performance!What does have to do with performance is the talent of the compiler / interpreter author, nothing more, nothing less.C implements ++ and so forth and so on.
Pascal does not, you have to express it as var := var + x or in some implementations as inc(var) or inc(var,100).
The smart compiler / interpreter author would implement those in the fastest possible way regardless of the particular language.This is all wishful thinking.
In practice, language design does have very serious performance implications.Here's one simple example.
Java doesn't have user-defined structural value types (i.e.
types with structural equality and no inherent referential identity), only reference types.
C# has both (structs vs classes).
Value types are generally more efficient because the compiler doesn't always need to heap-allocate them, doesn't have to guarantee meaningful referential identity comparison for them, and doesn't need to support "null" as a special value.Now, in theory, an optimizing Java JIT can analyze how a type is actually used in the code, and deduce from its usage that it is actually treated as a value type, and then optimize it accordingly.
However, this requires some quite advanced escape analysis technques - so much so that, IIRC, only the upcoming major Java release actually has this feature.
Meanwhile, all C# implementations just do what the programmer told them (by identifying the type as "struct" = value type), enjoying the performance increase.
It has been estimated that C# structs are one of the most important factors of why Java doesn't overtake C# performance-wise (because otherwise Java has a better GC and JIT).To sum it up: yes, in theory, it is possible to make a perfect whole-program optimizing compiler that can do every trick imaginable, from ideal type inference to escape analysis.
In practice, we're still about as far from that as we are from working, production-quality fusion power plants.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158899</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28163487</id>
	<title>Re:What kind of verbosity?</title>
	<author>setagllib</author>
	<datestamp>1243784460000</datestamp>
	<modclass>Informativ</modclass>
	<modscore>2</modscore>
	<htmltext><p>Scala, just as type-safe as C++ with good performance and excellent JVM integration:</p><p>scala&gt; val list = List(3, 4, 2, 1)<br>list: List[Int] = List(3, 4, 2, 1)</p><p>scala&gt; list foreach println<br>3<br>4<br>2<br>1</p><p>You know very well this is a big deal for the future of programming.</p></htmltext>
<tokenext>Scala , just as type-safe as C + + with good performance and excellent JVM integration : scala &gt; val list = List ( 3 , 4 , 2 , 1 ) list : List [ Int ] = List ( 3 , 4 , 2 , 1 ) scala &gt; list foreach println3421You know very well this is a big deal for the future of programming .</tokentext>
<sentencetext>Scala, just as type-safe as C++ with good performance and excellent JVM integration:scala&gt; val list = List(3, 4, 2, 1)list: List[Int] = List(3, 4, 2, 1)scala&gt; list foreach println3421You know very well this is a big deal for the future of programming.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28161725</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28165889</id>
	<title>Re:Verbosity is bad because</title>
	<author>Anonymous</author>
	<datestamp>1243857180000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p><div class="quote"><p>Verbosity = ( 1 / Expressiveness )</p></div><p>It gets much worse when Expressiveness = 0</p></div>
	</htmltext>
<tokenext>Verbosity = ( 1 / Expressiveness ) It gets much worse when Expressiveness = 0</tokentext>
<sentencetext>Verbosity = ( 1 / Expressiveness )It gets much worse when Expressiveness = 0
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158387</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158283</id>
	<title>Related site...</title>
	<author>Anonymous</author>
	<datestamp>1243785420000</datestamp>
	<modclass>Informativ</modclass>
	<modscore>4</modscore>
	<htmltext><a href="http://99-bottles-of-beer.net/" title="99-bottles-of-beer.net" rel="nofollow">This site</a> [99-bottles-of-beer.net] is awesome. It's very simple. They have over code in over 1200 different languages that spits out the lyrics to the "99 bottles of beer on the wall" song. Check out the perl example (yes, it really does work): <a href="http://99-bottles-of-beer.net/language-perl-737.html" title="99-bottles-of-beer.net" rel="nofollow">http://99-bottles-of-beer.net/language-perl-737.html</a> [99-bottles-of-beer.net]</htmltext>
<tokenext>This site [ 99-bottles-of-beer.net ] is awesome .
It 's very simple .
They have over code in over 1200 different languages that spits out the lyrics to the " 99 bottles of beer on the wall " song .
Check out the perl example ( yes , it really does work ) : http : //99-bottles-of-beer.net/language-perl-737.html [ 99-bottles-of-beer.net ]</tokentext>
<sentencetext>This site [99-bottles-of-beer.net] is awesome.
It's very simple.
They have over code in over 1200 different languages that spits out the lyrics to the "99 bottles of beer on the wall" song.
Check out the perl example (yes, it really does work): http://99-bottles-of-beer.net/language-perl-737.html [99-bottles-of-beer.net]</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158369</id>
	<title>Where are the old standards?</title>
	<author>Anonymous</author>
	<datestamp>1243786140000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>I'm a bit rusty on my languages too, but what about ML, Haskell and other pure functional languages? Scheme?</p><p>And what about the old standards? Fortran, Cobol and Common Lisp still do a lot of the world's work. C/C++, while a member of the family, doesn't encapsulate them.</p><p>I guess expressiveness gets at the idea that programmer hours are more important than compiler or runtime hours for most applications, but the link isn't real clear.  And maintainability--probably the most important characteristic of any language long term--isn't covered very well either.</p></htmltext>
<tokenext>I 'm a bit rusty on my languages too , but what about ML , Haskell and other pure functional languages ?
Scheme ? And what about the old standards ?
Fortran , Cobol and Common Lisp still do a lot of the world 's work .
C/C + + , while a member of the family , does n't encapsulate them.I guess expressiveness gets at the idea that programmer hours are more important than compiler or runtime hours for most applications , but the link is n't real clear .
And maintainability--probably the most important characteristic of any language long term--is n't covered very well either .</tokentext>
<sentencetext>I'm a bit rusty on my languages too, but what about ML, Haskell and other pure functional languages?
Scheme?And what about the old standards?
Fortran, Cobol and Common Lisp still do a lot of the world's work.
C/C++, while a member of the family, doesn't encapsulate them.I guess expressiveness gets at the idea that programmer hours are more important than compiler or runtime hours for most applications, but the link isn't real clear.
And maintainability--probably the most important characteristic of any language long term--isn't covered very well either.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28162313</id>
	<title>Re:The perfect language exists, you ignorant clod!</title>
	<author>Anonymous</author>
	<datestamp>1243774680000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Clearly the ideal language is Unix shell scripts!</p><p>"./benchmark"</p><p>How concise is that, bitch?<br>And it was written in C and compiled, so it's faster than everything, too.</p></htmltext>
<tokenext>Clearly the ideal language is Unix shell scripts !
" ./benchmark " How concise is that , bitch ? And it was written in C and compiled , so it 's faster than everything , too .</tokentext>
<sentencetext>Clearly the ideal language is Unix shell scripts!
"./benchmark"How concise is that, bitch?And it was written in C and compiled, so it's faster than everything, too.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158335</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158775</id>
	<title>ccomparison of C  and CAS</title>
	<author>e**(i pi)-1</author>
	<datestamp>1243789560000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>2</modscore>
	<htmltext><tt>Computer algebra systems are high level programming language. Writing good code does not need<br>documentation.&nbsp; The code itself shows what is done. Here is an example which takes two pictures<br>and procuces a GIF movie interpolating them:<br><br>A=Import["image1.jpg"]; B=Import["image2.jpg"];<br>width=Length[A[[1,1]]]; height=Length[A[[1]]];<br>ImageInterpolate[t\_]:=Image[(t A[[1]]+B[[1]] (1-t)),Byte,ColorSpace-&gt;RGB,ImageSize-&gt;{width,height}];<br>Export["mix.gif",Table[ImageInterpolate[k/50],{k,0,50}],"GIF"]<br><br>It takes over a minute to process. A simple C program doing the same is a multiple times larger but also<br>needs multiple less time to process. But it needs to be documented because even simple things like<br>reading in a picture<br><br>&nbsp; fgets(buffer,1025,in);<br>&nbsp; if(strncmp(buffer,"P6",2)){<br>&nbsp; &nbsp; fprintf(stderr,"Unsupported file format (need PPM raw)\n");<br>&nbsp; &nbsp; exit(1);<br>&nbsp; }<br><br>&nbsp; do fgets(buffer,1025,in); while(*buffer == '#');&nbsp; &nbsp; &nbsp;// get picture dimension<br>&nbsp; x\_size = atoi(strtok(buffer," "));<br>&nbsp; y\_size = atoi(strtok(NULL," "));<br>&nbsp; fgets(buffer,1025,in);&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// get color map size<br>&nbsp; c\_size = atoi(buffer);<br><br>&nbsp; if((image = (char *) malloc(3*x\_size*y\_size*sizeof(char)))==NULL){<br>&nbsp; &nbsp; fprintf(stderr,"Memory allocation error while loading picture\n");<br>&nbsp; &nbsp; exit(1);<br>&nbsp; }<br><br>&nbsp; i = 0;<br>&nbsp; ptr = image;<br>&nbsp; while(!feof(in) &amp;&amp; i&lt;3*x\_size*y\_size){ *ptr++ = fgetc(in); i++;}<br>&nbsp; fclose(in);<br><br>But C it is worth the effort. For more advanced image manipulation tasks for example,<br>Mathematica often can no more be used,&nbsp; due to memory or just because it takes too long<br>(Math link does not help here very much since objects like a movie (a vector of images) can just<br>not be fed into computer algebra systems without getting into memory problems, which deals with a movie as a whole).<br>For computer vision stuff for example, one needs to deal with large chunks of the entire movie).<br>While the simplicity of programming with high level programming languages is compelling, speed often matters.<br><br>There is an other nice benefit of a simple language like C: the code will work in 20 years. Computer algebra<br>systems evolve very fast and much what is done today does not work tomorrow any more in a new version. Higher<br>level languages evolve also faster. And large junks of internal CAS code are a "black box" invisible for the<br>user. Both worlds makes sense: the low level primitive, transparent and fast low level language and the slower, but<br>extremely elegant high level language.<br></tt></htmltext>
<tokenext>Computer algebra systems are high level programming language .
Writing good code does not needdocumentation.   The code itself shows what is done .
Here is an example which takes two picturesand procuces a GIF movie interpolating them : A = Import [ " image1.jpg " ] ; B = Import [ " image2.jpg " ] ; width = Length [ A [ [ 1,1 ] ] ] ; height = Length [ A [ [ 1 ] ] ] ; ImageInterpolate [ t \ _ ] : = Image [ ( t A [ [ 1 ] ] + B [ [ 1 ] ] ( 1-t ) ) ,Byte,ColorSpace- &gt; RGB,ImageSize- &gt; { width,height } ] ; Export [ " mix.gif " ,Table [ ImageInterpolate [ k/50 ] , { k,0,50 } ] , " GIF " ] It takes over a minute to process .
A simple C program doing the same is a multiple times larger but alsoneeds multiple less time to process .
But it needs to be documented because even simple things likereading in a picture   fgets ( buffer,1025,in ) ;   if ( strncmp ( buffer , " P6 " ,2 ) ) {     fprintf ( stderr , " Unsupported file format ( need PPM raw ) \ n " ) ;     exit ( 1 ) ;   }   do fgets ( buffer,1025,in ) ; while ( * buffer = = ' # ' ) ;       // get picture dimension   x \ _size = atoi ( strtok ( buffer , " " ) ) ;   y \ _size = atoi ( strtok ( NULL , " " ) ) ;   fgets ( buffer,1025,in ) ;                                 // get color map size   c \ _size = atoi ( buffer ) ;   if ( ( image = ( char * ) malloc ( 3 * x \ _size * y \ _size * sizeof ( char ) ) ) = = NULL ) {     fprintf ( stderr , " Memory allocation error while loading picture \ n " ) ;     exit ( 1 ) ;   }   i = 0 ;   ptr = image ;   while ( ! feof ( in ) &amp;&amp; i   fclose ( in ) ; But C it is worth the effort .
For more advanced image manipulation tasks for example,Mathematica often can no more be used ,   due to memory or just because it takes too long ( Math link does not help here very much since objects like a movie ( a vector of images ) can justnot be fed into computer algebra systems without getting into memory problems , which deals with a movie as a whole ) .For computer vision stuff for example , one needs to deal with large chunks of the entire movie ) .While the simplicity of programming with high level programming languages is compelling , speed often matters.There is an other nice benefit of a simple language like C : the code will work in 20 years .
Computer algebrasystems evolve very fast and much what is done today does not work tomorrow any more in a new version .
Higherlevel languages evolve also faster .
And large junks of internal CAS code are a " black box " invisible for theuser .
Both worlds makes sense : the low level primitive , transparent and fast low level language and the slower , butextremely elegant high level language .</tokentext>
<sentencetext>Computer algebra systems are high level programming language.
Writing good code does not needdocumentation.  The code itself shows what is done.
Here is an example which takes two picturesand procuces a GIF movie interpolating them:A=Import["image1.jpg"]; B=Import["image2.jpg"];width=Length[A[[1,1]]]; height=Length[A[[1]]];ImageInterpolate[t\_]:=Image[(t A[[1]]+B[[1]] (1-t)),Byte,ColorSpace-&gt;RGB,ImageSize-&gt;{width,height}];Export["mix.gif",Table[ImageInterpolate[k/50],{k,0,50}],"GIF"]It takes over a minute to process.
A simple C program doing the same is a multiple times larger but alsoneeds multiple less time to process.
But it needs to be documented because even simple things likereading in a picture  fgets(buffer,1025,in);  if(strncmp(buffer,"P6",2)){    fprintf(stderr,"Unsupported file format (need PPM raw)\n");    exit(1);  }  do fgets(buffer,1025,in); while(*buffer == '#');     // get picture dimension  x\_size = atoi(strtok(buffer," "));  y\_size = atoi(strtok(NULL," "));  fgets(buffer,1025,in);                               // get color map size  c\_size = atoi(buffer);  if((image = (char *) malloc(3*x\_size*y\_size*sizeof(char)))==NULL){    fprintf(stderr,"Memory allocation error while loading picture\n");    exit(1);  }  i = 0;  ptr = image;  while(!feof(in) &amp;&amp; i  fclose(in);But C it is worth the effort.
For more advanced image manipulation tasks for example,Mathematica often can no more be used,  due to memory or just because it takes too long(Math link does not help here very much since objects like a movie (a vector of images) can justnot be fed into computer algebra systems without getting into memory problems, which deals with a movie as a whole).For computer vision stuff for example, one needs to deal with large chunks of the entire movie).While the simplicity of programming with high level programming languages is compelling, speed often matters.There is an other nice benefit of a simple language like C: the code will work in 20 years.
Computer algebrasystems evolve very fast and much what is done today does not work tomorrow any more in a new version.
Higherlevel languages evolve also faster.
And large junks of internal CAS code are a "black box" invisible for theuser.
Both worlds makes sense: the low level primitive, transparent and fast low level language and the slower, butextremely elegant high level language.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28162475</id>
	<title>Re:What kind of verbosity?</title>
	<author>Anonymous</author>
	<datestamp>1243775880000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>...and the only bug in the tersest one. Why print the list len(list) times?</p></htmltext>
<tokenext>...and the only bug in the tersest one .
Why print the list len ( list ) times ?</tokentext>
<sentencetext>...and the only bug in the tersest one.
Why print the list len(list) times?</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28162919</id>
	<title>Re:What kind of verbosity?</title>
	<author>kinkozmasta</author>
	<datestamp>1243779840000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p> <tt>
for(std::list&lt;Item*&gt; it=list.begin();it!=list.end();it++) { <br>
   cout &lt;&amp;lt (*it)-&gt;name &lt;&lt; "\n"; <br>
}
</tt></p> </div><p>Or you could do it the "real" c++ way and be less verbose with increased flexibility. <br> <br>

<tt>
copy(list.begin(), list.end(), ostream\_iterator&lt;Item*&gt;(cout, "\n"));
</tt></p></div>
	</htmltext>
<tokenext>for ( std : : list it = list.begin ( ) ; it ! = list.end ( ) ; it + + ) { cout name } Or you could do it the " real " c + + way and be less verbose with increased flexibility .
copy ( list.begin ( ) , list.end ( ) , ostream \ _iterator ( cout , " \ n " ) ) ;</tokentext>
<sentencetext> 
for(std::list it=list.begin();it!=list.end();it++) { 
   cout name 
}
 Or you could do it the "real" c++ way and be less verbose with increased flexibility.
copy(list.begin(), list.end(), ostream\_iterator(cout, "\n"));

	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28168101</id>
	<title>Re:What kind of verbosity?</title>
	<author>Anonymous</author>
	<datestamp>1243871280000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>I'll say.  Big difference in output too.</p><p>I think you meant print item?</p></htmltext>
<tokenext>I 'll say .
Big difference in output too.I think you meant print item ?</tokentext>
<sentencetext>I'll say.
Big difference in output too.I think you meant print item?</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160941</id>
	<title>Anonymous Coward</title>
	<author>Anonymous</author>
	<datestamp>1243762260000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>C is the only programming language you need if you are a competent programmer.  A good assembler is nice if the compiler isn't up to snuff.</p></htmltext>
<tokenext>C is the only programming language you need if you are a competent programmer .
A good assembler is nice if the compiler is n't up to snuff .</tokentext>
<sentencetext>C is the only programming language you need if you are a competent programmer.
A good assembler is nice if the compiler isn't up to snuff.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28162415</id>
	<title>Re:Ruby</title>
	<author>zuperduperman</author>
	<datestamp>1243775400000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I think the answer is partly that the different communities involved have mindsets that won't accept that kind of compromise.   Suggest to a Ruby coder that they should introduce into Ruby any feature that slows them down or stops them doing "magic" with the language and they'll laugh you out of town. They (as a community) despise it.  Key features of various frameworks they use rely on such foibles as modifying types on the fly at run time which make such optimization somewhere between hard and impossible.  So they've already rationalized themselves into a position that performance doesn't matter and developer productivity is far more important.  It's very hard to back down from there after so many people have bought into this mindset.</p><p>The best hope is with new languages.  C# does well, and I think Scala is very promising - it shows well in the graph here but it could do massively better if not for some of the outliers being addressed.   Scala is a very young language and actually does exactly what you suggest - it lets you optionally bring in enough "verbosity" to allow the compiler (or JVM, in this case) to optimize the heck out of the code.   The important thing is that the community around it has not idealogically rejected either performance or developer productivity as primary and are actively going after both.  So it's well situated to do better than most.</p></htmltext>
<tokenext>I think the answer is partly that the different communities involved have mindsets that wo n't accept that kind of compromise .
Suggest to a Ruby coder that they should introduce into Ruby any feature that slows them down or stops them doing " magic " with the language and they 'll laugh you out of town .
They ( as a community ) despise it .
Key features of various frameworks they use rely on such foibles as modifying types on the fly at run time which make such optimization somewhere between hard and impossible .
So they 've already rationalized themselves into a position that performance does n't matter and developer productivity is far more important .
It 's very hard to back down from there after so many people have bought into this mindset.The best hope is with new languages .
C # does well , and I think Scala is very promising - it shows well in the graph here but it could do massively better if not for some of the outliers being addressed .
Scala is a very young language and actually does exactly what you suggest - it lets you optionally bring in enough " verbosity " to allow the compiler ( or JVM , in this case ) to optimize the heck out of the code .
The important thing is that the community around it has not idealogically rejected either performance or developer productivity as primary and are actively going after both .
So it 's well situated to do better than most .</tokentext>
<sentencetext>I think the answer is partly that the different communities involved have mindsets that won't accept that kind of compromise.
Suggest to a Ruby coder that they should introduce into Ruby any feature that slows them down or stops them doing "magic" with the language and they'll laugh you out of town.
They (as a community) despise it.
Key features of various frameworks they use rely on such foibles as modifying types on the fly at run time which make such optimization somewhere between hard and impossible.
So they've already rationalized themselves into a position that performance doesn't matter and developer productivity is far more important.
It's very hard to back down from there after so many people have bought into this mindset.The best hope is with new languages.
C# does well, and I think Scala is very promising - it shows well in the graph here but it could do massively better if not for some of the outliers being addressed.
Scala is a very young language and actually does exactly what you suggest - it lets you optionally bring in enough "verbosity" to allow the compiler (or JVM, in this case) to optimize the heck out of the code.
The important thing is that the community around it has not idealogically rejected either performance or developer productivity as primary and are actively going after both.
So it's well situated to do better than most.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158689</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28161343</id>
	<title>Re:ccomparison of C and CAS</title>
	<author>janwedekind</author>
	<datestamp>1243766160000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><tt><br>require 'hornetseye'<br>include Hornetseye<br>a = MultiArray.load\_rgb24 'image1.jpg'<br>b = MultiArray.load\_rgb24 'image2.jpg'<br>output = MEncoderOutput.new 'test.avi', 15<br>for k in 0..50<br>
&nbsp; &nbsp; output.write a * ( k / 50.0 ) + b * ( ( 50.0 - k ) / 50.0 )<br>end<br></tt><br>I happen to develop a <a href="http://www.wedesoft.demon.co.uk/hornetseye-api/" title="demon.co.uk">Ruby library</a> [demon.co.uk] which can be applied to this problem. In this case it generates the 50 transitional frames (640x480) in less than 10 seconds. I tried GIF first, but generating GIF is indeed very slow, since it requires global colour-indexing. So this may be the real performance problem in your example. Even so you should use Ruby<nobr> <wbr></nobr>;)</p></htmltext>
<tokenext>require 'hornetseye'include Hornetseyea = MultiArray.load \ _rgb24 'image1.jpg'b = MultiArray.load \ _rgb24 'image2.jpg'output = MEncoderOutput.new 'test.avi ' , 15for k in 0..50     output.write a * ( k / 50.0 ) + b * ( ( 50.0 - k ) / 50.0 ) endI happen to develop a Ruby library [ demon.co.uk ] which can be applied to this problem .
In this case it generates the 50 transitional frames ( 640x480 ) in less than 10 seconds .
I tried GIF first , but generating GIF is indeed very slow , since it requires global colour-indexing .
So this may be the real performance problem in your example .
Even so you should use Ruby ; )</tokentext>
<sentencetext>require 'hornetseye'include Hornetseyea = MultiArray.load\_rgb24 'image1.jpg'b = MultiArray.load\_rgb24 'image2.jpg'output = MEncoderOutput.new 'test.avi', 15for k in 0..50
    output.write a * ( k / 50.0 ) + b * ( ( 50.0 - k ) / 50.0 )endI happen to develop a Ruby library [demon.co.uk] which can be applied to this problem.
In this case it generates the 50 transitional frames (640x480) in less than 10 seconds.
I tried GIF first, but generating GIF is indeed very slow, since it requires global colour-indexing.
So this may be the real performance problem in your example.
Even so you should use Ruby ;)</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158775</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160047</id>
	<title>Re:Ocaml</title>
	<author>david.given</author>
	<datestamp>1243799040000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>3</modscore>
	<htmltext><p>A while back I tried implementing a project in OCaml, because it looked awesome, and I wanted to explore it.

</p><p>I found a lot to like about it; it's fast, reasonably clear, has got lots of awesome functional programming features that I actually found myself using while also having a powerful set of imperative programming features for the rest of the logic, and in general worked rather well.

</p><p>However, I kept finding myself running again and again into problems caused by the same conceptual design issue, which eventually led to me giving up in frustration.

</p><p>The problem was this: an OCaml program is structured as a series of statements, each of which mutates the program in some manner (usually by adding a definition to it). The last statement in the program typically invokes something (such as a 'main' function). The compiler ensures that your program is consistent after every statement. This means that you can't do forward declarations.

</p><p>There <i>is</i> an <tt>and</tt> construct that allows you to define several items of the same kind in a single statement, which is typically used to implement mutually recursive functions, but that doesn't help if you need to items of different kinds to be mutually recursive: for example, a class and an algebraic data type (which I needed to do lots, in order to implement 'object or None' semantics).

</p><p>I found this issue everywhere I looked in OCaml; the language semantics require your code dependency graph to be a tree with no cycles, and you have to structure your program strictly in bottom-up form. So not only can you not have two mutually dependent modules, you can't even put your 'main' at the top of the file for clarity.

</p><p>Now, my OCaml skills aren't particularly great, so there may be a way round this, but I spent a lot of time looking for a solution to this and didn't find one. This, and other lesser issues to do with code style and namespacing, smell unpleasantly like an academic language that hasn't really learnt to scale gracefully, and I wonder whether it would be a comfortable choice for implementing large projects. These days I'd be inclined to consider Haskell or Clean instead.</p></htmltext>
<tokenext>A while back I tried implementing a project in OCaml , because it looked awesome , and I wanted to explore it .
I found a lot to like about it ; it 's fast , reasonably clear , has got lots of awesome functional programming features that I actually found myself using while also having a powerful set of imperative programming features for the rest of the logic , and in general worked rather well .
However , I kept finding myself running again and again into problems caused by the same conceptual design issue , which eventually led to me giving up in frustration .
The problem was this : an OCaml program is structured as a series of statements , each of which mutates the program in some manner ( usually by adding a definition to it ) .
The last statement in the program typically invokes something ( such as a 'main ' function ) .
The compiler ensures that your program is consistent after every statement .
This means that you ca n't do forward declarations .
There is an and construct that allows you to define several items of the same kind in a single statement , which is typically used to implement mutually recursive functions , but that does n't help if you need to items of different kinds to be mutually recursive : for example , a class and an algebraic data type ( which I needed to do lots , in order to implement 'object or None ' semantics ) .
I found this issue everywhere I looked in OCaml ; the language semantics require your code dependency graph to be a tree with no cycles , and you have to structure your program strictly in bottom-up form .
So not only can you not have two mutually dependent modules , you ca n't even put your 'main ' at the top of the file for clarity .
Now , my OCaml skills are n't particularly great , so there may be a way round this , but I spent a lot of time looking for a solution to this and did n't find one .
This , and other lesser issues to do with code style and namespacing , smell unpleasantly like an academic language that has n't really learnt to scale gracefully , and I wonder whether it would be a comfortable choice for implementing large projects .
These days I 'd be inclined to consider Haskell or Clean instead .</tokentext>
<sentencetext>A while back I tried implementing a project in OCaml, because it looked awesome, and I wanted to explore it.
I found a lot to like about it; it's fast, reasonably clear, has got lots of awesome functional programming features that I actually found myself using while also having a powerful set of imperative programming features for the rest of the logic, and in general worked rather well.
However, I kept finding myself running again and again into problems caused by the same conceptual design issue, which eventually led to me giving up in frustration.
The problem was this: an OCaml program is structured as a series of statements, each of which mutates the program in some manner (usually by adding a definition to it).
The last statement in the program typically invokes something (such as a 'main' function).
The compiler ensures that your program is consistent after every statement.
This means that you can't do forward declarations.
There is an and construct that allows you to define several items of the same kind in a single statement, which is typically used to implement mutually recursive functions, but that doesn't help if you need to items of different kinds to be mutually recursive: for example, a class and an algebraic data type (which I needed to do lots, in order to implement 'object or None' semantics).
I found this issue everywhere I looked in OCaml; the language semantics require your code dependency graph to be a tree with no cycles, and you have to structure your program strictly in bottom-up form.
So not only can you not have two mutually dependent modules, you can't even put your 'main' at the top of the file for clarity.
Now, my OCaml skills aren't particularly great, so there may be a way round this, but I spent a lot of time looking for a solution to this and didn't find one.
This, and other lesser issues to do with code style and namespacing, smell unpleasantly like an academic language that hasn't really learnt to scale gracefully, and I wonder whether it would be a comfortable choice for implementing large projects.
These days I'd be inclined to consider Haskell or Clean instead.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158953</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158375</id>
	<title>Pet peeve</title>
	<author>Anonymous</author>
	<datestamp>1243786260000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>5</modscore>
	<htmltext><p>Programming <i>languages</i> don't have attributes like size and speed: <i>implementations</i> of these languages do. Take Common Lisp for example: SBCL is blazing fast, while CLISP is rather pudgy (albeit smaller). Any conforming Common Lisp program will run on both. Or consider Python --- IronPython and CPython have different performance characteristics. (I'm too lazy to link these now.)</p><p>Point being, describing a programming language as "fast" makes about as much senese as describing a natural, human language as "smart".</p></htmltext>
<tokenext>Programming languages do n't have attributes like size and speed : implementations of these languages do .
Take Common Lisp for example : SBCL is blazing fast , while CLISP is rather pudgy ( albeit smaller ) .
Any conforming Common Lisp program will run on both .
Or consider Python --- IronPython and CPython have different performance characteristics .
( I 'm too lazy to link these now .
) Point being , describing a programming language as " fast " makes about as much senese as describing a natural , human language as " smart " .</tokentext>
<sentencetext>Programming languages don't have attributes like size and speed: implementations of these languages do.
Take Common Lisp for example: SBCL is blazing fast, while CLISP is rather pudgy (albeit smaller).
Any conforming Common Lisp program will run on both.
Or consider Python --- IronPython and CPython have different performance characteristics.
(I'm too lazy to link these now.
)Point being, describing a programming language as "fast" makes about as much senese as describing a natural, human language as "smart".</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159763</id>
	<title>Re:Ocaml</title>
	<author>Anonymous</author>
	<datestamp>1243796940000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Don't worry, your just not that clever.  Functional languages fit smart people's brains fairly well.  And tehy are a real boon if you ever need to describe an algorithm that is actually complicated, as opposed to the usual trivialities most programers deal with daily.</p><p>But functional languages are quite the bitch to optimize at the compiler level, partially because they have so many many more optimizations available, but mostly because the compiler must do the optimizations humans might normally do (or the humans must describe the optimizations other ways).</p><p>One day, almost all code will be written in purely functional languages because they are so much easier to parallelize, but not today.</p></htmltext>
<tokenext>Do n't worry , your just not that clever .
Functional languages fit smart people 's brains fairly well .
And tehy are a real boon if you ever need to describe an algorithm that is actually complicated , as opposed to the usual trivialities most programers deal with daily.But functional languages are quite the bitch to optimize at the compiler level , partially because they have so many many more optimizations available , but mostly because the compiler must do the optimizations humans might normally do ( or the humans must describe the optimizations other ways ) .One day , almost all code will be written in purely functional languages because they are so much easier to parallelize , but not today .</tokentext>
<sentencetext>Don't worry, your just not that clever.
Functional languages fit smart people's brains fairly well.
And tehy are a real boon if you ever need to describe an algorithm that is actually complicated, as opposed to the usual trivialities most programers deal with daily.But functional languages are quite the bitch to optimize at the compiler level, partially because they have so many many more optimizations available, but mostly because the compiler must do the optimizations humans might normally do (or the humans must describe the optimizations other ways).One day, almost all code will be written in purely functional languages because they are so much easier to parallelize, but not today.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158731</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159487</id>
	<title>Re:Ocaml</title>
	<author>alphabetsoup</author>
	<datestamp>1243795080000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I wonder the same. But I hope with the introduction of F# on VS 2010, functional programming will finally catch on. If anybody has the muscle to push a new language, its MS.</p></htmltext>
<tokenext>I wonder the same .
But I hope with the introduction of F # on VS 2010 , functional programming will finally catch on .
If anybody has the muscle to push a new language , its MS .</tokentext>
<sentencetext>I wonder the same.
But I hope with the introduction of F# on VS 2010, functional programming will finally catch on.
If anybody has the muscle to push a new language, its MS.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158575</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158543</id>
	<title>Re:Pet peeve</title>
	<author>DoofusOfDeath</author>
	<datestamp>1243787700000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><blockquote><div><p>Point being, describing a programming language as "fast" makes about as much senese as describing a natural, human language as "smart".</p></div></blockquote><p>Yeah, will if human language isn't smart, just what language DO you suggest we use???</p><p>Goddam Vorons... troll ever fucking thread they read.</p></div>
	</htmltext>
<tokenext>Point being , describing a programming language as " fast " makes about as much senese as describing a natural , human language as " smart " .Yeah , will if human language is n't smart , just what language DO you suggest we use ? ?
? Goddam Vorons... troll ever fucking thread they read .</tokentext>
<sentencetext>Point being, describing a programming language as "fast" makes about as much senese as describing a natural, human language as "smart".Yeah, will if human language isn't smart, just what language DO you suggest we use??
?Goddam Vorons... troll ever fucking thread they read.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158375</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28161739</id>
	<title>Re:What kind of verbosity?</title>
	<author>Anonymous</author>
	<datestamp>1243769460000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>FYI, In your first example I think you meant to write "print item" rather than "print list"</p></htmltext>
<tokenext>FYI , In your first example I think you meant to write " print item " rather than " print list "</tokentext>
<sentencetext>FYI, In your first example I think you meant to write "print item" rather than "print list"</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28163191</id>
	<title>Re:This is totaly stupid</title>
	<author>sribe</author>
	<datestamp>1243782180000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>The verbs, nouns, semantics and such used in a given programming language have nothing, I repeat... NOTHING to do with performance!</p></div><p>Wow, this is so deeply untrue that it's flat-out sad it's getting modded up as insightful. Semantics do have a profound influence on what optimizations can be performed, and when, and at what cost.</p></div>
	</htmltext>
<tokenext>The verbs , nouns , semantics and such used in a given programming language have nothing , I repeat... NOTHING to do with performance ! Wow , this is so deeply untrue that it 's flat-out sad it 's getting modded up as insightful .
Semantics do have a profound influence on what optimizations can be performed , and when , and at what cost .</tokentext>
<sentencetext>The verbs, nouns, semantics and such used in a given programming language have nothing, I repeat... NOTHING to do with performance!Wow, this is so deeply untrue that it's flat-out sad it's getting modded up as insightful.
Semantics do have a profound influence on what optimizations can be performed, and when, and at what cost.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158899</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28161135</id>
	<title>Re:Where are the real lanaguages???</title>
	<author>jd</author>
	<datestamp>1243764060000</datestamp>
	<modclass>Funny</modclass>
	<modscore>2</modscore>
	<htmltext><p>They wrapped round. You have to turn the PNG over and look at the back.</p></htmltext>
<tokenext>They wrapped round .
You have to turn the PNG over and look at the back .</tokentext>
<sentencetext>They wrapped round.
You have to turn the PNG over and look at the back.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158405</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28161725</id>
	<title>Re:What kind of verbosity?</title>
	<author>jgrahn</author>
	<datestamp>1243769340000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>&gt; for(std::list it=list.begin();it!=list.end();it++) {<br>&gt;    cout name  }</p><p>You obfuscated the C++ version with pointers and a 'name' member. It should have gone</p><p>for(std::list it=list.begin(); it!=list.end(); ++it) {<br>
&nbsp; &nbsp; &nbsp; cout  *it  "\n";<br>}</p><p>Still uglier than Python, but at least it's fast and type-safe.</p></htmltext>
<tokenext>&gt; for ( std : : list it = list.begin ( ) ; it ! = list.end ( ) ; it + + ) { &gt; cout name } You obfuscated the C + + version with pointers and a 'name ' member .
It should have gonefor ( std : : list it = list.begin ( ) ; it ! = list.end ( ) ; + + it ) {       cout * it " \ n " ; } Still uglier than Python , but at least it 's fast and type-safe .</tokentext>
<sentencetext>&gt; for(std::list it=list.begin();it!=list.end();it++) {&gt;    cout name  }You obfuscated the C++ version with pointers and a 'name' member.
It should have gonefor(std::list it=list.begin(); it!=list.end(); ++it) {
      cout  *it  "\n";}Still uglier than Python, but at least it's fast and type-safe.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158737</id>
	<title>Be aware of your contexts.</title>
	<author>cabazorro</author>
	<datestamp>1243789380000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>2</modscore>
	<htmltext><p>Contexts can be deceiving.<br>Be careful not to use these charts to decide what language to learn or what language is better for a given solution.<br>Let's remember the web server ecosystems: cgi, c#, perl, java, python, php, ruby.<br>A given algorithm implemented in you language of choice can give you the upper hand<br>and instant notoriety; but running the whole operation (labor/maintenance/testing) goes far beyond<br>controlled environment testing.</p><p>Lately I've been thinking that<br>the more powerful solution (language wise) is the one that you can build and tear down from scratch in less time/effort.<br>That gives you more confidence to try new/innovative solutions.<br>my 2 cents.</p></htmltext>
<tokenext>Contexts can be deceiving.Be careful not to use these charts to decide what language to learn or what language is better for a given solution.Let 's remember the web server ecosystems : cgi , c # , perl , java , python , php , ruby.A given algorithm implemented in you language of choice can give you the upper handand instant notoriety ; but running the whole operation ( labor/maintenance/testing ) goes far beyondcontrolled environment testing.Lately I 've been thinking thatthe more powerful solution ( language wise ) is the one that you can build and tear down from scratch in less time/effort.That gives you more confidence to try new/innovative solutions.my 2 cents .</tokentext>
<sentencetext>Contexts can be deceiving.Be careful not to use these charts to decide what language to learn or what language is better for a given solution.Let's remember the web server ecosystems: cgi, c#, perl, java, python, php, ruby.A given algorithm implemented in you language of choice can give you the upper handand instant notoriety; but running the whole operation (labor/maintenance/testing) goes far beyondcontrolled environment testing.Lately I've been thinking thatthe more powerful solution (language wise) is the one that you can build and tear down from scratch in less time/effort.That gives you more confidence to try new/innovative solutions.my 2 cents.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158953</id>
	<title>Re:Ocaml</title>
	<author>Anonymous</author>
	<datestamp>1243791000000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>4</modscore>
	<htmltext><p>To be honest, I have the same reaction. I love OCaml, and am frustrated by the fact it hasn't been adopted more. It seems like a no-brainer to me.</p><p>I've been following it over time, and I think the reasons for it have become clearer to me.</p><p>1. I think the biggest reason is hard to articulate well, but basically I think the OCaml developers are sort of unresponsive to the community, which has been embryonic as it is, and as a result there's a sense that it's not moving in directions it should be. Numerical applications, for example, are one domain where OCaml interest has really been high, but the developers have been pretty unresponsive to concerns about matrix implementations. Comments by the developers on concurrency have also puzzled a lot of people. I don't mean to sound like a troll, but I have gotten the sense over time that while OCaml is wonderful as it is, it's not changing or moving anywhere, at least as quickly as it should be (in a bad way). Haskell is a good comparison to me in this regard, as it's a language that is also functional, but not as useful in applications than it is theoretically. However, Haskell has a wonderfully strong community, it is almost a model of how a language and its implementations can grow in a productive way.</p><p>2. OCaml is occupying a difficult position, in that people who want cold, hard performance with stable implementations will go somewhere else (e.g., C); people who want theoretically elegant implementations will go somewhere else (e.g., Lisp, haskell), and people who want something simple will go somewhere else still (e.g., Python, Ruby). OCaml in many ways occupies all three places, but not quite as well as any one of them.</p><p>Having said all of that, it's important to keep in mind that Microsoft is sort of pushing F# for 2010. F# is essentially a Microsoft implementation of OCaml for the CLR--very very close to OCaml--so maybe if F# takes off, there will be a big push toward OCaml.</p><p>It's one of the few times I could say that Microsoft is really on target technically, and might actually move the numerical computing field forward.</p></htmltext>
<tokenext>To be honest , I have the same reaction .
I love OCaml , and am frustrated by the fact it has n't been adopted more .
It seems like a no-brainer to me.I 've been following it over time , and I think the reasons for it have become clearer to me.1 .
I think the biggest reason is hard to articulate well , but basically I think the OCaml developers are sort of unresponsive to the community , which has been embryonic as it is , and as a result there 's a sense that it 's not moving in directions it should be .
Numerical applications , for example , are one domain where OCaml interest has really been high , but the developers have been pretty unresponsive to concerns about matrix implementations .
Comments by the developers on concurrency have also puzzled a lot of people .
I do n't mean to sound like a troll , but I have gotten the sense over time that while OCaml is wonderful as it is , it 's not changing or moving anywhere , at least as quickly as it should be ( in a bad way ) .
Haskell is a good comparison to me in this regard , as it 's a language that is also functional , but not as useful in applications than it is theoretically .
However , Haskell has a wonderfully strong community , it is almost a model of how a language and its implementations can grow in a productive way.2 .
OCaml is occupying a difficult position , in that people who want cold , hard performance with stable implementations will go somewhere else ( e.g. , C ) ; people who want theoretically elegant implementations will go somewhere else ( e.g. , Lisp , haskell ) , and people who want something simple will go somewhere else still ( e.g. , Python , Ruby ) .
OCaml in many ways occupies all three places , but not quite as well as any one of them.Having said all of that , it 's important to keep in mind that Microsoft is sort of pushing F # for 2010 .
F # is essentially a Microsoft implementation of OCaml for the CLR--very very close to OCaml--so maybe if F # takes off , there will be a big push toward OCaml.It 's one of the few times I could say that Microsoft is really on target technically , and might actually move the numerical computing field forward .</tokentext>
<sentencetext>To be honest, I have the same reaction.
I love OCaml, and am frustrated by the fact it hasn't been adopted more.
It seems like a no-brainer to me.I've been following it over time, and I think the reasons for it have become clearer to me.1.
I think the biggest reason is hard to articulate well, but basically I think the OCaml developers are sort of unresponsive to the community, which has been embryonic as it is, and as a result there's a sense that it's not moving in directions it should be.
Numerical applications, for example, are one domain where OCaml interest has really been high, but the developers have been pretty unresponsive to concerns about matrix implementations.
Comments by the developers on concurrency have also puzzled a lot of people.
I don't mean to sound like a troll, but I have gotten the sense over time that while OCaml is wonderful as it is, it's not changing or moving anywhere, at least as quickly as it should be (in a bad way).
Haskell is a good comparison to me in this regard, as it's a language that is also functional, but not as useful in applications than it is theoretically.
However, Haskell has a wonderfully strong community, it is almost a model of how a language and its implementations can grow in a productive way.2.
OCaml is occupying a difficult position, in that people who want cold, hard performance with stable implementations will go somewhere else (e.g., C); people who want theoretically elegant implementations will go somewhere else (e.g., Lisp, haskell), and people who want something simple will go somewhere else still (e.g., Python, Ruby).
OCaml in many ways occupies all three places, but not quite as well as any one of them.Having said all of that, it's important to keep in mind that Microsoft is sort of pushing F# for 2010.
F# is essentially a Microsoft implementation of OCaml for the CLR--very very close to OCaml--so maybe if F# takes off, there will be a big push toward OCaml.It's one of the few times I could say that Microsoft is really on target technically, and might actually move the numerical computing field forward.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158575</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28166197</id>
	<title>Now let me guess what language you use...</title>
	<author>foxylad</author>
	<datestamp>1243860660000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Seriously, I'm and old c/c++ hand, lately turned to Python for most work because I enjoy it. But the reality is that very few of us get much choice - we have to use whatever system the PHB got swayed by back in the day.</p><p>So I wouldn't get too upset by this article, even if Java is your pride and joy - I doubt we'll see a stampede to Stalin. Java programmers will remain java programmers, just like those poor buggers who started out in Cobol are still hacking away in Cobol.</p></htmltext>
<tokenext>Seriously , I 'm and old c/c + + hand , lately turned to Python for most work because I enjoy it .
But the reality is that very few of us get much choice - we have to use whatever system the PHB got swayed by back in the day.So I would n't get too upset by this article , even if Java is your pride and joy - I doubt we 'll see a stampede to Stalin .
Java programmers will remain java programmers , just like those poor buggers who started out in Cobol are still hacking away in Cobol .</tokentext>
<sentencetext>Seriously, I'm and old c/c++ hand, lately turned to Python for most work because I enjoy it.
But the reality is that very few of us get much choice - we have to use whatever system the PHB got swayed by back in the day.So I wouldn't get too upset by this article, even if Java is your pride and joy - I doubt we'll see a stampede to Stalin.
Java programmers will remain java programmers, just like those poor buggers who started out in Cobol are still hacking away in Cobol.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28161395</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159597</id>
	<title>Re:This is totaly stupid</title>
	<author>smallfries</author>
	<datestamp>1243795860000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>So language semantics have nothing to do with performance eh? Oh dear. Your experience is clearly much more limited than you estimate it to be. There's a big old world of languages and implementation techniques out there that it would benefit you to learn about.</p><p>From a comment like that you clearly have no idea of the impact on using pass-by-copy or pass-by-reference semantics in a language. Furthermore you are unable to establish what sort of features would make the pass-by-copy faster as it is more amenable to analysis and optimisation. Do you know the difference between static and dynamic despatch in a language, and the performance costs of each? Do you where closures and co-routines can improve performance if the language provides decent support for the programmer to use them?</p><p>Lastly there is the issue of programmer efficiency, as opposed to machine efficiency. If I can code up a problem solution in 1/10 of the time using a higher level language, then the relative efficiency of my high level language and a low level language become very important. People who have learnt more expressive languages than Pascal and C can write code in them much more quickly, and concisely than a low level implementation. For those who are more experienced that you are, the trade-off between verbosity and performance is very important.</p></htmltext>
<tokenext>So language semantics have nothing to do with performance eh ?
Oh dear .
Your experience is clearly much more limited than you estimate it to be .
There 's a big old world of languages and implementation techniques out there that it would benefit you to learn about.From a comment like that you clearly have no idea of the impact on using pass-by-copy or pass-by-reference semantics in a language .
Furthermore you are unable to establish what sort of features would make the pass-by-copy faster as it is more amenable to analysis and optimisation .
Do you know the difference between static and dynamic despatch in a language , and the performance costs of each ?
Do you where closures and co-routines can improve performance if the language provides decent support for the programmer to use them ? Lastly there is the issue of programmer efficiency , as opposed to machine efficiency .
If I can code up a problem solution in 1/10 of the time using a higher level language , then the relative efficiency of my high level language and a low level language become very important .
People who have learnt more expressive languages than Pascal and C can write code in them much more quickly , and concisely than a low level implementation .
For those who are more experienced that you are , the trade-off between verbosity and performance is very important .</tokentext>
<sentencetext>So language semantics have nothing to do with performance eh?
Oh dear.
Your experience is clearly much more limited than you estimate it to be.
There's a big old world of languages and implementation techniques out there that it would benefit you to learn about.From a comment like that you clearly have no idea of the impact on using pass-by-copy or pass-by-reference semantics in a language.
Furthermore you are unable to establish what sort of features would make the pass-by-copy faster as it is more amenable to analysis and optimisation.
Do you know the difference between static and dynamic despatch in a language, and the performance costs of each?
Do you where closures and co-routines can improve performance if the language provides decent support for the programmer to use them?Lastly there is the issue of programmer efficiency, as opposed to machine efficiency.
If I can code up a problem solution in 1/10 of the time using a higher level language, then the relative efficiency of my high level language and a low level language become very important.
People who have learnt more expressive languages than Pascal and C can write code in them much more quickly, and concisely than a low level implementation.
For those who are more experienced that you are, the trade-off between verbosity and performance is very important.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158899</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158733</id>
	<title>Re:C best language out there - what about for web?</title>
	<author>Anonymous</author>
	<datestamp>1243789380000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>C has never caught on for web development, unless you consider C#.</p><p>I thing that browser based applications are going to be even more common in the future.</p></htmltext>
<tokenext>C has never caught on for web development , unless you consider C # .I thing that browser based applications are going to be even more common in the future .</tokentext>
<sentencetext>C has never caught on for web development, unless you consider C#.I thing that browser based applications are going to be even more common in the future.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158413</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159411</id>
	<title>Re:Ocaml</title>
	<author>TheTyrannyOfForcedRe</author>
	<datestamp>1243794480000</datestamp>
	<modclass>Troll</modclass>
	<modscore>0</modscore>
	<htmltext>There are two explanations for that.  #1 You haven't put enough work into learning them.  #2 You're not smart enough to be a programmer.</htmltext>
<tokenext>There are two explanations for that .
# 1 You have n't put enough work into learning them .
# 2 You 're not smart enough to be a programmer .</tokentext>
<sentencetext>There are two explanations for that.
#1 You haven't put enough work into learning them.
#2 You're not smart enough to be a programmer.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158731</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159117</id>
	<title>Servers are cheap and getting cheaper</title>
	<author>Anonymous</author>
	<datestamp>1243792380000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Servers are cheap and are becoming cheaper all the time. It's much cheaper to load balance between multiple servers or upgrade current servers when necessary, than it is to pay programmers to code in a verbose language, especially for new companies or products that aren't doing millions of transactions everyday.</p><p>Performance isn't all about processor efficiency.</p></htmltext>
<tokenext>Servers are cheap and are becoming cheaper all the time .
It 's much cheaper to load balance between multiple servers or upgrade current servers when necessary , than it is to pay programmers to code in a verbose language , especially for new companies or products that are n't doing millions of transactions everyday.Performance is n't all about processor efficiency .</tokentext>
<sentencetext>Servers are cheap and are becoming cheaper all the time.
It's much cheaper to load balance between multiple servers or upgrade current servers when necessary, than it is to pay programmers to code in a verbose language, especially for new companies or products that aren't doing millions of transactions everyday.Performance isn't all about processor efficiency.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158689</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28165199</id>
	<title>Re:Scala</title>
	<author>TheTurtlesMoves</author>
	<datestamp>1243846920000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>Its a benchmark. Thats it. Was the scala writen by a scala coder or a C programmer. Is the C writen by a<nobr> <wbr></nobr>... etc. There are so many things to consider that it should all be taken with salt. It will taste better that way.</htmltext>
<tokenext>Its a benchmark .
Thats it .
Was the scala writen by a scala coder or a C programmer .
Is the C writen by a ... etc. There are so many things to consider that it should all be taken with salt .
It will taste better that way .</tokentext>
<sentencetext>Its a benchmark.
Thats it.
Was the scala writen by a scala coder or a C programmer.
Is the C writen by a ... etc. There are so many things to consider that it should all be taken with salt.
It will taste better that way.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158307</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158747</id>
	<title>Re:what about APL</title>
	<author>mdmkolbe</author>
	<datestamp>1243789440000</datestamp>
	<modclass>Informativ</modclass>
	<modscore>4</modscore>
	<htmltext><p>If you would like APL to be on the list, then submit benchmarks for APL to the <a href="http://shootout.alioth.debian.org/" title="debian.org">Shootout</a> [debian.org] (the blog got its data fro there).  The Shootout is mainly driven by user submissions.  They do have some fairly strict rules about how to submit.  However, if you can name an implementation (along with enough guidelines to make installing it easy) and provide a reasonably full set of benchmarks, then the language will generally be added.</p><p>One tip about submitting though: try to make life as easy as possible for the guy who runs it.  He doesn't have time to figure out typos or to fix "easy" bugs in some programming language they he may not even know.</p></htmltext>
<tokenext>If you would like APL to be on the list , then submit benchmarks for APL to the Shootout [ debian.org ] ( the blog got its data fro there ) .
The Shootout is mainly driven by user submissions .
They do have some fairly strict rules about how to submit .
However , if you can name an implementation ( along with enough guidelines to make installing it easy ) and provide a reasonably full set of benchmarks , then the language will generally be added.One tip about submitting though : try to make life as easy as possible for the guy who runs it .
He does n't have time to figure out typos or to fix " easy " bugs in some programming language they he may not even know .</tokentext>
<sentencetext>If you would like APL to be on the list, then submit benchmarks for APL to the Shootout [debian.org] (the blog got its data fro there).
The Shootout is mainly driven by user submissions.
They do have some fairly strict rules about how to submit.
However, if you can name an implementation (along with enough guidelines to make installing it easy) and provide a reasonably full set of benchmarks, then the language will generally be added.One tip about submitting though: try to make life as easy as possible for the guy who runs it.
He doesn't have time to figure out typos or to fix "easy" bugs in some programming language they he may not even know.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158219</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158757</id>
	<title>Re:Pet peeve</title>
	<author>Twinbee</author>
	<datestamp>1243789440000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I don't agree. The concise and almost 'joyful' programming languages like Ruby *lend* themselves to generally running slower for the reason that it's much harder to create a fast compiler for them than the others. It's still possible, but much, much harder to do so.</p></htmltext>
<tokenext>I do n't agree .
The concise and almost 'joyful ' programming languages like Ruby * lend * themselves to generally running slower for the reason that it 's much harder to create a fast compiler for them than the others .
It 's still possible , but much , much harder to do so .</tokentext>
<sentencetext>I don't agree.
The concise and almost 'joyful' programming languages like Ruby *lend* themselves to generally running slower for the reason that it's much harder to create a fast compiler for them than the others.
It's still possible, but much, much harder to do so.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158375</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158973</id>
	<title>Re:What kind of verbosity?</title>
	<author>gdshaw</author>
	<datestamp>1243791060000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I look at it this way.  Verbosity that I the programmer<nobr> <wbr></nobr>/choose/ to add in the interests of readability is generally good.</p><p>Verbosity required by the language, the standard libraries, or some sadist who happened to write the coding standard, is almost invariably bad.</p></htmltext>
<tokenext>I look at it this way .
Verbosity that I the programmer /choose/ to add in the interests of readability is generally good.Verbosity required by the language , the standard libraries , or some sadist who happened to write the coding standard , is almost invariably bad .</tokentext>
<sentencetext>I look at it this way.
Verbosity that I the programmer /choose/ to add in the interests of readability is generally good.Verbosity required by the language, the standard libraries, or some sadist who happened to write the coding standard, is almost invariably bad.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158425</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28163845</id>
	<title>Re:What kind of verbosity?</title>
	<author>Anonymous</author>
	<datestamp>1243787280000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>while(lst.Next())<br>
&nbsp; &nbsp; &nbsp; Print(lst.Current());</p><p>The above is C++. Just because there is a concoction called "The Standard C++ Library" doesn't mean you have to use the monstrosity. I suggest that my example is of the thing that resides in the bottom left of the chart.</p><p>(Your example is unclear (or at least the semantics of the languages other than C++ you gave are so ugly as to be confusing) so I assumed your example was one wanting to "print" the whole list, which is clearly (to me) what the C++ example you gave does).</p></htmltext>
<tokenext>while ( lst.Next ( ) )       Print ( lst.Current ( ) ) ; The above is C + + .
Just because there is a concoction called " The Standard C + + Library " does n't mean you have to use the monstrosity .
I suggest that my example is of the thing that resides in the bottom left of the chart .
( Your example is unclear ( or at least the semantics of the languages other than C + + you gave are so ugly as to be confusing ) so I assumed your example was one wanting to " print " the whole list , which is clearly ( to me ) what the C + + example you gave does ) .</tokentext>
<sentencetext>while(lst.Next())
      Print(lst.Current());The above is C++.
Just because there is a concoction called "The Standard C++ Library" doesn't mean you have to use the monstrosity.
I suggest that my example is of the thing that resides in the bottom left of the chart.
(Your example is unclear (or at least the semantics of the languages other than C++ you gave are so ugly as to be confusing) so I assumed your example was one wanting to "print" the whole list, which is clearly (to me) what the C++ example you gave does).</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158743</id>
	<title>Re:what about APL</title>
	<author>DavidHumus</author>
	<datestamp>1243789380000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>One language that might be terser is J: see jsoftware.org.</p><p>For instance, Newton's method is written</p><p>N=: 1 : '- u \% u d. 1'</p><p>(see <a href="http://www.jsoftware.com/jwiki/Essays/Newton's" title="jsoftware.com" rel="nofollow">http://www.jsoftware.com/jwiki/Essays/Newton's</a> [jsoftware.com] Method)</p><p>However, about the claim of APL being faster than C, this is only true if you're talking about development time (which may be the most important metric).  An interpreted language like APL or J might approach the execution speed of C for operations on large arrays but the interpretive overhead will always impose a performance penalty.</p></htmltext>
<tokenext>One language that might be terser is J : see jsoftware.org.For instance , Newton 's method is writtenN = : 1 : '- u \ % u d. 1 ' ( see http : //www.jsoftware.com/jwiki/Essays/Newton 's [ jsoftware.com ] Method ) However , about the claim of APL being faster than C , this is only true if you 're talking about development time ( which may be the most important metric ) .
An interpreted language like APL or J might approach the execution speed of C for operations on large arrays but the interpretive overhead will always impose a performance penalty .</tokentext>
<sentencetext>One language that might be terser is J: see jsoftware.org.For instance, Newton's method is writtenN=: 1 : '- u \% u d. 1'(see http://www.jsoftware.com/jwiki/Essays/Newton's [jsoftware.com] Method)However, about the claim of APL being faster than C, this is only true if you're talking about development time (which may be the most important metric).
An interpreted language like APL or J might approach the execution speed of C for operations on large arrays but the interpretive overhead will always impose a performance penalty.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158219</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28161325</id>
	<title>Short answer</title>
	<author>hey!</author>
	<datestamp>1243765980000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>the kind that applies the detail you are looking or <strong>right now</strong>, but no others.  Oh, yes, I really mean <strong>right now, whether or not you know what it is</strong>.  That's ideal.</p></htmltext>
<tokenext>the kind that applies the detail you are looking or right now , but no others .
Oh , yes , I really mean right now , whether or not you know what it is .
That 's ideal .</tokentext>
<sentencetext>the kind that applies the detail you are looking or right now, but no others.
Oh, yes, I really mean right now, whether or not you know what it is.
That's ideal.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158425</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28175893</id>
	<title>Re:C best language out there</title>
	<author>Kazoo the Clown</author>
	<datestamp>1243861620000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p> <i>Now don't get me wrong. C is a great portable assembly language. It's close to the metal, widely known and easy to read. But as far as programming languages go, C feature poor.</i> </p><p>I would agree with this-- and with all these now deprecated functions (replaced with "safe" ones) designed to eliminate programmer bad habits, it's become something of a nightmare...</p></htmltext>
<tokenext>Now do n't get me wrong .
C is a great portable assembly language .
It 's close to the metal , widely known and easy to read .
But as far as programming languages go , C feature poor .
I would agree with this-- and with all these now deprecated functions ( replaced with " safe " ones ) designed to eliminate programmer bad habits , it 's become something of a nightmare.. .</tokentext>
<sentencetext> Now don't get me wrong.
C is a great portable assembly language.
It's close to the metal, widely known and easy to read.
But as far as programming languages go, C feature poor.
I would agree with this-- and with all these now deprecated functions (replaced with "safe" ones) designed to eliminate programmer bad habits, it's become something of a nightmare...</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159155</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28170017</id>
	<title>Re:What kind of verbosity?</title>
	<author>Anonymous</author>
	<datestamp>1243879740000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Purposefully making things more verbose?  Priceless.<br>
&nbsp; <br>Someone has an agenda.</p></htmltext>
<tokenext>Purposefully making things more verbose ?
Priceless .   Someone has an agenda .</tokentext>
<sentencetext>Purposefully making things more verbose?
Priceless.
  Someone has an agenda.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28169019</id>
	<title>Re:What kind of verbosity?</title>
	<author>Anonymous</author>
	<datestamp>1243875240000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>C++0x:</p><p>for (Item &amp;o : list)<br>
&nbsp; &nbsp; &nbsp; &nbsp; cout  o;</p><p>Get with the times. Your C++ is below C++89 standard - overload operator as you do with the other languages for a somewhat comparable result. You forgot "::iterator" and you used it++ whereas it's common practice (and on bad compilers quicker) to use ++it.</p></htmltext>
<tokenext>C + + 0x : for ( Item &amp;o : list )         cout o ; Get with the times .
Your C + + is below C + + 89 standard - overload operator as you do with the other languages for a somewhat comparable result .
You forgot " : : iterator " and you used it + + whereas it 's common practice ( and on bad compilers quicker ) to use + + it .</tokentext>
<sentencetext>C++0x:for (Item &amp;o : list)
        cout  o;Get with the times.
Your C++ is below C++89 standard - overload operator as you do with the other languages for a somewhat comparable result.
You forgot "::iterator" and you used it++ whereas it's common practice (and on bad compilers quicker) to use ++it.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28305633</id>
	<title>Re:C best language out there</title>
	<author>Anonymous</author>
	<datestamp>1244803560000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p><div class="quote"><p>Ha ha.  Good joke.  You've forgotten the most important feature "needed in a great programming lang": <a href="http://en.wikipedia.org/wiki/Higher-order\_function" title="wikipedia.org" rel="nofollow">higher-order</a> [wikipedia.org] and <a href="http://en.wikipedia.org/wiki/First-class\_function" title="wikipedia.org" rel="nofollow">first-class</a> [wikipedia.org] functions with proper <a href="http://en.wikipedia.org/wiki/Closure\_(computer\_science)" title="wikipedia.org" rel="nofollow">closures</a> [wikipedia.org].  Oh wait, C doesn't have that.</p><p>Any truly great statically typed language will also have at least <a href="http://en.wikipedia.org/wiki/Algebraic\_data\_type" title="wikipedia.org" rel="nofollow">algebraic data types</a> [wikipedia.org], <a href="http://en.wikipedia.org/wiki/Polymorphism\_(computer\_science)" title="wikipedia.org" rel="nofollow">parametric polymorphism</a> [wikipedia.org] (even C++ only has ad-hoc polymorphism), type constructors and functions, maybe even a Turing complete type system (heh).  C doesn't have any of those.</p><p>Even aside from types, great languages should include <a href="http://en.wikipedia.org/wiki/Tail\_call" title="wikipedia.org" rel="nofollow">tail-call optimization</a> [wikipedia.org], <a href="http://en.wikipedia.org/wiki/Pattern\_matching" title="wikipedia.org" rel="nofollow">pattern matching</a> [wikipedia.org] and <a href="http://en.wikipedia.org/wiki/Hygienic\_macros" title="wikipedia.org" rel="nofollow">hygienic macros</a> [wikipedia.org] (CPP macros are a bad joke).</p><p>Now don't get me wrong.  C is a great portable assembly language.  It's close to the metal, widely known and easy to read.  But as far as programming languages go, C feature poor.</p></div><p>test</p></div>
	</htmltext>
<tokenext>Ha ha .
Good joke .
You 've forgotten the most important feature " needed in a great programming lang " : higher-order [ wikipedia.org ] and first-class [ wikipedia.org ] functions with proper closures [ wikipedia.org ] .
Oh wait , C does n't have that.Any truly great statically typed language will also have at least algebraic data types [ wikipedia.org ] , parametric polymorphism [ wikipedia.org ] ( even C + + only has ad-hoc polymorphism ) , type constructors and functions , maybe even a Turing complete type system ( heh ) .
C does n't have any of those.Even aside from types , great languages should include tail-call optimization [ wikipedia.org ] , pattern matching [ wikipedia.org ] and hygienic macros [ wikipedia.org ] ( CPP macros are a bad joke ) .Now do n't get me wrong .
C is a great portable assembly language .
It 's close to the metal , widely known and easy to read .
But as far as programming languages go , C feature poor.test</tokentext>
<sentencetext>Ha ha.
Good joke.
You've forgotten the most important feature "needed in a great programming lang": higher-order [wikipedia.org] and first-class [wikipedia.org] functions with proper closures [wikipedia.org].
Oh wait, C doesn't have that.Any truly great statically typed language will also have at least algebraic data types [wikipedia.org], parametric polymorphism [wikipedia.org] (even C++ only has ad-hoc polymorphism), type constructors and functions, maybe even a Turing complete type system (heh).
C doesn't have any of those.Even aside from types, great languages should include tail-call optimization [wikipedia.org], pattern matching [wikipedia.org] and hygienic macros [wikipedia.org] (CPP macros are a bad joke).Now don't get me wrong.
C is a great portable assembly language.
It's close to the metal, widely known and easy to read.
But as far as programming languages go, C feature poor.test
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159155</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159743</id>
	<title>Re:This is totaly stupid</title>
	<author>Anonymous</author>
	<datestamp>1243796820000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>2</modscore>
	<htmltext><p><div class="quote"><p>The verbs, nouns, semantics and such used in a given programming language have <b>nothing</b>, I repeat... <b>NOTHING</b> to do with performance!</p><p>What <b>does</b> have to do with performance is the talent of the compiler / interpreter author, nothing more, nothing less.</p></div><p>The empirical evidence then tells us that the authors of assemblers are more talented than those of C compilers, who are in turn more talented that the authors of compilers/interpreters of JITs and dynamic languages.  Put another way, you're wrong.</p></div>
	</htmltext>
<tokenext>The verbs , nouns , semantics and such used in a given programming language have nothing , I repeat... NOTHING to do with performance ! What does have to do with performance is the talent of the compiler / interpreter author , nothing more , nothing less.The empirical evidence then tells us that the authors of assemblers are more talented than those of C compilers , who are in turn more talented that the authors of compilers/interpreters of JITs and dynamic languages .
Put another way , you 're wrong .</tokentext>
<sentencetext>The verbs, nouns, semantics and such used in a given programming language have nothing, I repeat... NOTHING to do with performance!What does have to do with performance is the talent of the compiler / interpreter author, nothing more, nothing less.The empirical evidence then tells us that the authors of assemblers are more talented than those of C compilers, who are in turn more talented that the authors of compilers/interpreters of JITs and dynamic languages.
Put another way, you're wrong.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158899</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158223</id>
	<title>Why is Verbosity Bad?</title>
	<author>eldavojohn</author>
	<datestamp>1243784760000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>5</modscore>
	<htmltext>
This plots verbosity against slowness making:<p><div class="quote"><p>And finally, in the bottom left corner you would find probably nothing, since this is the space of the ideal language, the one which is at the same time fast and short and a joy to use.</p> </div><p>I must ask why the author assumes that verbosity is bad and why lack thereof makes it a "joy to use."  <br> <br>

I think verbosity in moderation is necessary.  I have read many an article with developers arguing that they don't need to document their code when their code is self-documenting.  Do you make all of your variables and class/function/methods a single character for the sake of verbosity?  I hope not.  And I would think that reading and maintaining that code would be far less than a joy.  <br> <br>

I don't even need to argue this, according to his graphs we should all be using Regina, Mlton or Stalin (a scheme implementation).  But instead languages like Java and Perl and C++ prevail.  And I would guess that support and a mediocre range of verbosity are what causes that.  <br> <br>

Great work in these graphs!  But in my opinion, verbosity when used in moderation--like a lot things--is far better than either extreme.</p></div>
	</htmltext>
<tokenext>This plots verbosity against slowness making : And finally , in the bottom left corner you would find probably nothing , since this is the space of the ideal language , the one which is at the same time fast and short and a joy to use .
I must ask why the author assumes that verbosity is bad and why lack thereof makes it a " joy to use .
" I think verbosity in moderation is necessary .
I have read many an article with developers arguing that they do n't need to document their code when their code is self-documenting .
Do you make all of your variables and class/function/methods a single character for the sake of verbosity ?
I hope not .
And I would think that reading and maintaining that code would be far less than a joy .
I do n't even need to argue this , according to his graphs we should all be using Regina , Mlton or Stalin ( a scheme implementation ) .
But instead languages like Java and Perl and C + + prevail .
And I would guess that support and a mediocre range of verbosity are what causes that .
Great work in these graphs !
But in my opinion , verbosity when used in moderation--like a lot things--is far better than either extreme .</tokentext>
<sentencetext>
This plots verbosity against slowness making:And finally, in the bottom left corner you would find probably nothing, since this is the space of the ideal language, the one which is at the same time fast and short and a joy to use.
I must ask why the author assumes that verbosity is bad and why lack thereof makes it a "joy to use.
"   

I think verbosity in moderation is necessary.
I have read many an article with developers arguing that they don't need to document their code when their code is self-documenting.
Do you make all of your variables and class/function/methods a single character for the sake of verbosity?
I hope not.
And I would think that reading and maintaining that code would be far less than a joy.
I don't even need to argue this, according to his graphs we should all be using Regina, Mlton or Stalin (a scheme implementation).
But instead languages like Java and Perl and C++ prevail.
And I would guess that support and a mediocre range of verbosity are what causes that.
Great work in these graphs!
But in my opinion, verbosity when used in moderation--like a lot things--is far better than either extreme.
	</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28164323</id>
	<title>Re:What kind of verbosity?</title>
	<author>Anonymous</author>
	<datestamp>1243791900000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>a shortened version of your c++ example</p><p>BOOST\_FOREACH(Item * item, list)<br>
&nbsp; &nbsp; &nbsp; &nbsp; cout name  "\n";</p></htmltext>
<tokenext>a shortened version of your c + + exampleBOOST \ _FOREACH ( Item * item , list )         cout name " \ n " ;</tokentext>
<sentencetext>a shortened version of your c++ exampleBOOST\_FOREACH(Item * item, list)
        cout name  "\n";</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28163425</id>
	<title>Re:What kind of verbosity?</title>
	<author>thechao</author>
	<datestamp>1243783980000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Let me amend that last line of code for you (C++0x, auto variables and for-range loops):</p><blockquote><div><p> <tt>for (auto it : list)<br>
&nbsp; cout &lt;&lt; (*it)-&gt;name &lt;&lt; "\n";</tt></p></div> </blockquote><p>... although, I am not going to argue that, in general, C++ is a damn wordy language.</p></div>
	</htmltext>
<tokenext>Let me amend that last line of code for you ( C + + 0x , auto variables and for-range loops ) : for ( auto it : list )   cout name ... although , I am not going to argue that , in general , C + + is a damn wordy language .</tokentext>
<sentencetext>Let me amend that last line of code for you (C++0x, auto variables and for-range loops): for (auto it : list)
  cout name  ... although, I am not going to argue that, in general, C++ is a damn wordy language.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28172651</id>
	<title>Re:Pet peeve</title>
	<author>bored</author>
	<datestamp>1243847040000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><i>Clever engineers know that 95\% of their code is not performance critical at all (i.e. cpu idling most of the time), and that it makes a hell of a lot of sense to do whatever is necessary to get that 5\% performing as best as possible if the cost in terms of stability, productivity, security, portability, etc is low enough. That's why server-side c is not a commonly required job skill.</i></p><p>Server side, web development isn't done in C because the bottlenecks are almost always the database (which is written in C) and the IO bandwidth of the internet connection. That combined with the fact they are almost always custom, single company jobs. Given that there are a number of languages designed initially for web development. That they are better at it than C shouldn't surprise anyone. </p><p>You can be assured that just about every other kind of "server" <b>IS</b> written in C. The project I work on is handing more than 5GB (bytes!) of IO data a second per machine (fairly standard X86 hardware). That kind of IO throughput is simply not possible with most other languages. You don't see samba written in java for reasons similar to our project. The low level optimizations required to make it run fast just don't exist. Its also heavily dependent on the economies of scale. If your application runs on four servers at two sites, then there really isn't a reason to optimize it to run on a single server at each site. On the other hand if your application runs on two servers per site at 10k sites, then its a significant cost savings when you make it handle the same load on a single server. </p></htmltext>
<tokenext>Clever engineers know that 95 \ % of their code is not performance critical at all ( i.e .
cpu idling most of the time ) , and that it makes a hell of a lot of sense to do whatever is necessary to get that 5 \ % performing as best as possible if the cost in terms of stability , productivity , security , portability , etc is low enough .
That 's why server-side c is not a commonly required job skill.Server side , web development is n't done in C because the bottlenecks are almost always the database ( which is written in C ) and the IO bandwidth of the internet connection .
That combined with the fact they are almost always custom , single company jobs .
Given that there are a number of languages designed initially for web development .
That they are better at it than C should n't surprise anyone .
You can be assured that just about every other kind of " server " IS written in C. The project I work on is handing more than 5GB ( bytes !
) of IO data a second per machine ( fairly standard X86 hardware ) .
That kind of IO throughput is simply not possible with most other languages .
You do n't see samba written in java for reasons similar to our project .
The low level optimizations required to make it run fast just do n't exist .
Its also heavily dependent on the economies of scale .
If your application runs on four servers at two sites , then there really is n't a reason to optimize it to run on a single server at each site .
On the other hand if your application runs on two servers per site at 10k sites , then its a significant cost savings when you make it handle the same load on a single server .</tokentext>
<sentencetext>Clever engineers know that 95\% of their code is not performance critical at all (i.e.
cpu idling most of the time), and that it makes a hell of a lot of sense to do whatever is necessary to get that 5\% performing as best as possible if the cost in terms of stability, productivity, security, portability, etc is low enough.
That's why server-side c is not a commonly required job skill.Server side, web development isn't done in C because the bottlenecks are almost always the database (which is written in C) and the IO bandwidth of the internet connection.
That combined with the fact they are almost always custom, single company jobs.
Given that there are a number of languages designed initially for web development.
That they are better at it than C shouldn't surprise anyone.
You can be assured that just about every other kind of "server" IS written in C. The project I work on is handing more than 5GB (bytes!
) of IO data a second per machine (fairly standard X86 hardware).
That kind of IO throughput is simply not possible with most other languages.
You don't see samba written in java for reasons similar to our project.
The low level optimizations required to make it run fast just don't exist.
Its also heavily dependent on the economies of scale.
If your application runs on four servers at two sites, then there really isn't a reason to optimize it to run on a single server at each site.
On the other hand if your application runs on two servers per site at 10k sites, then its a significant cost savings when you make it handle the same load on a single server. </sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160795</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159419</id>
	<title>Re:Forth, the RPN notational programming language</title>
	<author>rbrander</author>
	<datestamp>1243794540000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>5</modscore>
	<htmltext><p>I fell hard for FORTH in the mid-80's - it was the programming language of some instrumentation I had to work with.  I never did program the instrumentation, but got all the books on the language and interpreters/compilers (the distinction blurs in FORTH...) for it for a number of computers.  I did some useful utilities for the PC using "HS/FORTH".  I benchmarked it against some other solutions for a course in comparitive computer languages about 1985, and for heavily stack-based (ie very recursive) programs, nothing could touch it.  I'm talking QuickSort faster than C.</p><p>But I have to admit: though I busted butt, re-writing and re-re-writing programs to make them as clear and readable as possible, though I re-read the remarkable "Thinking FORTH" by Leo Brodie many times (and would recommend it to anybody who wants to understand the craft of programming, whether they want to learn FORTH or not)....despite it all, most of my FORTH programs were hard to read a few months later.</p><p>There were things it was really good at - that is, the programs WERE readable later, the problem and language were a match - and others where I could just not seem to decompose the problem into FORTH words that fitted well together without a lot of "glue" to manipulate the parameters on the stack.</p><p>That was the most frequent problem with my FORTH programming - one ends up trying to manage several parameters on the stack and doing a lot of stack "DUP SWAP ROTATE" - actions to line up the parameters to hand to the next word.   I would re-compose the words and the parameters they wanted to clean up some code, and find I'd made some other code all hard to read.</p><p>FORTH was also profoundly command-line oriented, and when the word went all GUI-centric on me with no good "Visual FORTH" or "Tk/FORTH" on the horizon, I slipped from grace.  I can't see getting back to it now, either; lets face it, a huge bonus for any programming language choice is its popularity, so that others will maintain your code, so that you can get help and code fragments with a quick google.</p><p>But I still think that FORTH should be a completely MANDATORY learning experience in all University and Tech CompSci degrees.  You can jump from C to Perl to Python far more easily than to FORTH - it really comes at problems from another angle and working with it for years has been an enormous asset to my non-linear thinking when it comes to problem-solving.</p><p>And perhaps if more students learned it, FORTH would rise in popularity for some problems, out of its decades-long sinecure in embedded systems (it started off programming radio telescopes, and undoubtedly still does...)   Since it is inherently object-oriented (yes, an assembler-sized OO language from the 1970's, you heard that correctly) it would be an excellent interpretive, experimentation-friendly scripting language for applications.  I'm currently needing to do a lot of VBA in Excel at work, and I have a strong suspicion I'd be twice as productive in "FORTH for Applications".   It's a tragedy Bill Gates fell for BASIC (of all languages) instead.</p></htmltext>
<tokenext>I fell hard for FORTH in the mid-80 's - it was the programming language of some instrumentation I had to work with .
I never did program the instrumentation , but got all the books on the language and interpreters/compilers ( the distinction blurs in FORTH... ) for it for a number of computers .
I did some useful utilities for the PC using " HS/FORTH " .
I benchmarked it against some other solutions for a course in comparitive computer languages about 1985 , and for heavily stack-based ( ie very recursive ) programs , nothing could touch it .
I 'm talking QuickSort faster than C.But I have to admit : though I busted butt , re-writing and re-re-writing programs to make them as clear and readable as possible , though I re-read the remarkable " Thinking FORTH " by Leo Brodie many times ( and would recommend it to anybody who wants to understand the craft of programming , whether they want to learn FORTH or not ) ....despite it all , most of my FORTH programs were hard to read a few months later.There were things it was really good at - that is , the programs WERE readable later , the problem and language were a match - and others where I could just not seem to decompose the problem into FORTH words that fitted well together without a lot of " glue " to manipulate the parameters on the stack.That was the most frequent problem with my FORTH programming - one ends up trying to manage several parameters on the stack and doing a lot of stack " DUP SWAP ROTATE " - actions to line up the parameters to hand to the next word .
I would re-compose the words and the parameters they wanted to clean up some code , and find I 'd made some other code all hard to read.FORTH was also profoundly command-line oriented , and when the word went all GUI-centric on me with no good " Visual FORTH " or " Tk/FORTH " on the horizon , I slipped from grace .
I ca n't see getting back to it now , either ; lets face it , a huge bonus for any programming language choice is its popularity , so that others will maintain your code , so that you can get help and code fragments with a quick google.But I still think that FORTH should be a completely MANDATORY learning experience in all University and Tech CompSci degrees .
You can jump from C to Perl to Python far more easily than to FORTH - it really comes at problems from another angle and working with it for years has been an enormous asset to my non-linear thinking when it comes to problem-solving.And perhaps if more students learned it , FORTH would rise in popularity for some problems , out of its decades-long sinecure in embedded systems ( it started off programming radio telescopes , and undoubtedly still does... ) Since it is inherently object-oriented ( yes , an assembler-sized OO language from the 1970 's , you heard that correctly ) it would be an excellent interpretive , experimentation-friendly scripting language for applications .
I 'm currently needing to do a lot of VBA in Excel at work , and I have a strong suspicion I 'd be twice as productive in " FORTH for Applications " .
It 's a tragedy Bill Gates fell for BASIC ( of all languages ) instead .</tokentext>
<sentencetext>I fell hard for FORTH in the mid-80's - it was the programming language of some instrumentation I had to work with.
I never did program the instrumentation, but got all the books on the language and interpreters/compilers (the distinction blurs in FORTH...) for it for a number of computers.
I did some useful utilities for the PC using "HS/FORTH".
I benchmarked it against some other solutions for a course in comparitive computer languages about 1985, and for heavily stack-based (ie very recursive) programs, nothing could touch it.
I'm talking QuickSort faster than C.But I have to admit: though I busted butt, re-writing and re-re-writing programs to make them as clear and readable as possible, though I re-read the remarkable "Thinking FORTH" by Leo Brodie many times (and would recommend it to anybody who wants to understand the craft of programming, whether they want to learn FORTH or not)....despite it all, most of my FORTH programs were hard to read a few months later.There were things it was really good at - that is, the programs WERE readable later, the problem and language were a match - and others where I could just not seem to decompose the problem into FORTH words that fitted well together without a lot of "glue" to manipulate the parameters on the stack.That was the most frequent problem with my FORTH programming - one ends up trying to manage several parameters on the stack and doing a lot of stack "DUP SWAP ROTATE" - actions to line up the parameters to hand to the next word.
I would re-compose the words and the parameters they wanted to clean up some code, and find I'd made some other code all hard to read.FORTH was also profoundly command-line oriented, and when the word went all GUI-centric on me with no good "Visual FORTH" or "Tk/FORTH" on the horizon, I slipped from grace.
I can't see getting back to it now, either; lets face it, a huge bonus for any programming language choice is its popularity, so that others will maintain your code, so that you can get help and code fragments with a quick google.But I still think that FORTH should be a completely MANDATORY learning experience in all University and Tech CompSci degrees.
You can jump from C to Perl to Python far more easily than to FORTH - it really comes at problems from another angle and working with it for years has been an enormous asset to my non-linear thinking when it comes to problem-solving.And perhaps if more students learned it, FORTH would rise in popularity for some problems, out of its decades-long sinecure in embedded systems (it started off programming radio telescopes, and undoubtedly still does...)   Since it is inherently object-oriented (yes, an assembler-sized OO language from the 1970's, you heard that correctly) it would be an excellent interpretive, experimentation-friendly scripting language for applications.
I'm currently needing to do a lot of VBA in Excel at work, and I have a strong suspicion I'd be twice as productive in "FORTH for Applications".
It's a tragedy Bill Gates fell for BASIC (of all languages) instead.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158377</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158623</id>
	<title>Re:Related site...</title>
	<author>Anonymous</author>
	<datestamp>1243788300000</datestamp>
	<modclass>Troll</modclass>
	<modscore>-1</modscore>
	<htmltext><p>So we already knew perl was the worst language in the world to write in and to have to maintain, but now we know that it's slow as hell, and no nearly as concise at it appears to be.  Now that's what I call a study.</p></htmltext>
<tokenext>So we already knew perl was the worst language in the world to write in and to have to maintain , but now we know that it 's slow as hell , and no nearly as concise at it appears to be .
Now that 's what I call a study .</tokentext>
<sentencetext>So we already knew perl was the worst language in the world to write in and to have to maintain, but now we know that it's slow as hell, and no nearly as concise at it appears to be.
Now that's what I call a study.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158283</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160795</id>
	<title>Re:Pet peeve</title>
	<author>jilles</author>
	<datestamp>1243761360000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>3</modscore>
	<htmltext><p>Yes of course you are right. And more recently we actually have languages with coherent and consistent behavior across implementations (somewhat of a novelty, just look at C implementations). There's several Ruby interpreters that run the Rails framework now. The fastest one (or so it is claimed often) is JRuby, which runs on top of the Java virtual machine, which has has quite many implementations on a wide variety of hardware optimized for running on e.g. embedded hardware or on CPUs with thousands of cores and impressive levels of compatibility given these differences. So saying language X is faster than language Y is a quite meaningless statement these days. Faster on what, and under what conditions and at what required level of stability, and with what kind of benchmark? Most C programs are fast, except they have all but 1 core on the CPU idling because threading and concurrency are very hard to bolt on to a C program. Which is why some performance critical messaging servers are done in languages like Erlang.</p><p>Most C programmers believe it is the closest thing to native aside from assembler. Probably correct if you ignore 40 years of progress in the hardware world but downright naive in light of modern day X86 processors. Technically x86 is not a native instruction set anymore but a virtual machine language that happens to have an in hardware translation to the 'real' instruction set. Like all such translations, it comes at a cost of lost flexibility, and indeed performance. But it is worth avoiding having to rewrite all those pesky compilers. So rather than shatter the assumptions C programmers make, they actually support them by sacrificing transistors. The only real difference between Java and C execution model (aside from better defined semantics in Java) is that Java does the translation in software, at run-time, taking into account performance characteristics of both the running program and the underlying hardware. That in a nutshell is why the LLVM project exists to do the same for C programs (and indeed many other languages, including Java).</p><p>Of course you have to take into account the levels of abstraction and indirection provided in application frameworks as well. Those come at a cost and that cost is typically high in scripting languages (but you get so much in return). Java is often unfairly compared to C. I say unfairly here because it is usually a comparison of application frameworks rather than the language implementation. Java is in 'laboratory' conditions quite fast, even comparable to C and applies all the same performance optimizations (and then some). Except, nobody programs Java that way (except some dude at work who managed to produce the suckiest Java class ever, different story) . Similarly, C mostly lacks the rich frameworks that are common in the Java world. Transcode a C program to Java and you end up with a code base that is still pretty fast (e.g. quake 2 has a Java port). Stupid people in both camps believe that it is an either-or type decision between the two and that it is somehow inherent to the language what you end up with. Clever engineers know that 95\% of their code is not performance critical at all (i.e. cpu idling most of the time), and that it makes a hell of  a lot of sense to do whatever is necessary to get that 5\% performing as best as possible if the cost in terms of stability, productivity, security, portability, etc is low enough. That's why server-side c is not a commonly required job skill.</p><p>That's why Apple used the llvm platform to port Mac OS X to mobile phones and why Google chose to implement a heavily customized Java vm on top of familiar C/C++ components to emulate their success. Good engineers know when to choose what. Both iphone and android are excellent achievements that move beyond the stupid status quo of wondering which language is better.</p></htmltext>
<tokenext>Yes of course you are right .
And more recently we actually have languages with coherent and consistent behavior across implementations ( somewhat of a novelty , just look at C implementations ) .
There 's several Ruby interpreters that run the Rails framework now .
The fastest one ( or so it is claimed often ) is JRuby , which runs on top of the Java virtual machine , which has has quite many implementations on a wide variety of hardware optimized for running on e.g .
embedded hardware or on CPUs with thousands of cores and impressive levels of compatibility given these differences .
So saying language X is faster than language Y is a quite meaningless statement these days .
Faster on what , and under what conditions and at what required level of stability , and with what kind of benchmark ?
Most C programs are fast , except they have all but 1 core on the CPU idling because threading and concurrency are very hard to bolt on to a C program .
Which is why some performance critical messaging servers are done in languages like Erlang.Most C programmers believe it is the closest thing to native aside from assembler .
Probably correct if you ignore 40 years of progress in the hardware world but downright naive in light of modern day X86 processors .
Technically x86 is not a native instruction set anymore but a virtual machine language that happens to have an in hardware translation to the 'real ' instruction set .
Like all such translations , it comes at a cost of lost flexibility , and indeed performance .
But it is worth avoiding having to rewrite all those pesky compilers .
So rather than shatter the assumptions C programmers make , they actually support them by sacrificing transistors .
The only real difference between Java and C execution model ( aside from better defined semantics in Java ) is that Java does the translation in software , at run-time , taking into account performance characteristics of both the running program and the underlying hardware .
That in a nutshell is why the LLVM project exists to do the same for C programs ( and indeed many other languages , including Java ) .Of course you have to take into account the levels of abstraction and indirection provided in application frameworks as well .
Those come at a cost and that cost is typically high in scripting languages ( but you get so much in return ) .
Java is often unfairly compared to C. I say unfairly here because it is usually a comparison of application frameworks rather than the language implementation .
Java is in 'laboratory ' conditions quite fast , even comparable to C and applies all the same performance optimizations ( and then some ) .
Except , nobody programs Java that way ( except some dude at work who managed to produce the suckiest Java class ever , different story ) .
Similarly , C mostly lacks the rich frameworks that are common in the Java world .
Transcode a C program to Java and you end up with a code base that is still pretty fast ( e.g .
quake 2 has a Java port ) .
Stupid people in both camps believe that it is an either-or type decision between the two and that it is somehow inherent to the language what you end up with .
Clever engineers know that 95 \ % of their code is not performance critical at all ( i.e .
cpu idling most of the time ) , and that it makes a hell of a lot of sense to do whatever is necessary to get that 5 \ % performing as best as possible if the cost in terms of stability , productivity , security , portability , etc is low enough .
That 's why server-side c is not a commonly required job skill.That 's why Apple used the llvm platform to port Mac OS X to mobile phones and why Google chose to implement a heavily customized Java vm on top of familiar C/C + + components to emulate their success .
Good engineers know when to choose what .
Both iphone and android are excellent achievements that move beyond the stupid status quo of wondering which language is better .</tokentext>
<sentencetext>Yes of course you are right.
And more recently we actually have languages with coherent and consistent behavior across implementations (somewhat of a novelty, just look at C implementations).
There's several Ruby interpreters that run the Rails framework now.
The fastest one (or so it is claimed often) is JRuby, which runs on top of the Java virtual machine, which has has quite many implementations on a wide variety of hardware optimized for running on e.g.
embedded hardware or on CPUs with thousands of cores and impressive levels of compatibility given these differences.
So saying language X is faster than language Y is a quite meaningless statement these days.
Faster on what, and under what conditions and at what required level of stability, and with what kind of benchmark?
Most C programs are fast, except they have all but 1 core on the CPU idling because threading and concurrency are very hard to bolt on to a C program.
Which is why some performance critical messaging servers are done in languages like Erlang.Most C programmers believe it is the closest thing to native aside from assembler.
Probably correct if you ignore 40 years of progress in the hardware world but downright naive in light of modern day X86 processors.
Technically x86 is not a native instruction set anymore but a virtual machine language that happens to have an in hardware translation to the 'real' instruction set.
Like all such translations, it comes at a cost of lost flexibility, and indeed performance.
But it is worth avoiding having to rewrite all those pesky compilers.
So rather than shatter the assumptions C programmers make, they actually support them by sacrificing transistors.
The only real difference between Java and C execution model (aside from better defined semantics in Java) is that Java does the translation in software, at run-time, taking into account performance characteristics of both the running program and the underlying hardware.
That in a nutshell is why the LLVM project exists to do the same for C programs (and indeed many other languages, including Java).Of course you have to take into account the levels of abstraction and indirection provided in application frameworks as well.
Those come at a cost and that cost is typically high in scripting languages (but you get so much in return).
Java is often unfairly compared to C. I say unfairly here because it is usually a comparison of application frameworks rather than the language implementation.
Java is in 'laboratory' conditions quite fast, even comparable to C and applies all the same performance optimizations (and then some).
Except, nobody programs Java that way (except some dude at work who managed to produce the suckiest Java class ever, different story) .
Similarly, C mostly lacks the rich frameworks that are common in the Java world.
Transcode a C program to Java and you end up with a code base that is still pretty fast (e.g.
quake 2 has a Java port).
Stupid people in both camps believe that it is an either-or type decision between the two and that it is somehow inherent to the language what you end up with.
Clever engineers know that 95\% of their code is not performance critical at all (i.e.
cpu idling most of the time), and that it makes a hell of  a lot of sense to do whatever is necessary to get that 5\% performing as best as possible if the cost in terms of stability, productivity, security, portability, etc is low enough.
That's why server-side c is not a commonly required job skill.That's why Apple used the llvm platform to port Mac OS X to mobile phones and why Google chose to implement a heavily customized Java vm on top of familiar C/C++ components to emulate their success.
Good engineers know when to choose what.
Both iphone and android are excellent achievements that move beyond the stupid status quo of wondering which language is better.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158375</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159065</id>
	<title>Re:What kind of verbosity?</title>
	<author>Raffaello</author>
	<datestamp>1243791960000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Yes. This suggests that a compressibility metric is a good inverse measure of a language's expressiveness. IOW, the more compressible the source is, the more the programmer has to repeat boilerplate code in that language. Expressive languages would not necessarily have the smallest code size, but they would have the smallest ratio of uncompressed source size to gzipped source size. It would be nice to see the submitter's graphs redone with code size replaced by:</p><p>code-size / gzipped-code-size</p></htmltext>
<tokenext>Yes .
This suggests that a compressibility metric is a good inverse measure of a language 's expressiveness .
IOW , the more compressible the source is , the more the programmer has to repeat boilerplate code in that language .
Expressive languages would not necessarily have the smallest code size , but they would have the smallest ratio of uncompressed source size to gzipped source size .
It would be nice to see the submitter 's graphs redone with code size replaced by : code-size / gzipped-code-size</tokentext>
<sentencetext>Yes.
This suggests that a compressibility metric is a good inverse measure of a language's expressiveness.
IOW, the more compressible the source is, the more the programmer has to repeat boilerplate code in that language.
Expressive languages would not necessarily have the smallest code size, but they would have the smallest ratio of uncompressed source size to gzipped source size.
It would be nice to see the submitter's graphs redone with code size replaced by:code-size / gzipped-code-size</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158425</parent>
</comment>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_41</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158809
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28164933
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_64</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158223
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158425
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28162919
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_37</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158413
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159155
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28175893
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_102</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158689
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158969
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_40</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158223
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158425
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28161739
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_98</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158219
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159073
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_71</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158375
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28161021
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_89</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158307
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160417
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_14</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158775
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28166225
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_28</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158335
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28162313
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_88</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158689
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158871
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_21</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158223
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158425
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28164223
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_95</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158223
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158425
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28165575
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_5</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158223
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158425
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28163093
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_11</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158575
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160557
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_69</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158575
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158731
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159763
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_72</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158377
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159419
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28175869
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_4</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158405
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159839
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_63</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158689
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28163465
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_108</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158375
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158757
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_34</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158223
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158425
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158973
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_59</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158223
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158425
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28164323
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_62</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158307
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158819
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_53</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158223
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158425
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28166463
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_27</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158283
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158623
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_30</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158307
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160987
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_87</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158219
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158747
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28174401
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_114</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158377
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28171657
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_26</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158405
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158845
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_92</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158223
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158425
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28163435
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_17</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158223
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158425
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28164935
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_78</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158405
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28161135
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_54</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158775
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28161343
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_3</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158755
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28165437
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_82</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158413
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158657
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_56</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160159
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28165035
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_61</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158223
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158425
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28162767
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28169407
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_106</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158219
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158743
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_32</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158689
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28161003
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_75</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158335
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158939
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_18</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158575
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158731
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159099
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_46</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158413
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158889
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_111</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158413
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159155
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159631
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_51</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158223
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158425
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28161557
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_25</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158689
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28188203
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_101</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158377
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159419
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28164399
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_99</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158689
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28162415
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_9</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158223
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158425
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28170071
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_90</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158223
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158471
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_15</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158755
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159161
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_81</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158223
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158465
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_76</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158223
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158425
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28163845
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_67</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158375
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160795
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28172591
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_20</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158223
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158425
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28165315
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_38</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158223
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158425
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28162475
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_80</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158575
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158953
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160047
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_43</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158899
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160521
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_66</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158223
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158425
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28162379
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_45</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158335
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159809
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_68</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158689
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159117
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_73</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158331
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28162647
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_44</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158575
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28164093
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_109</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158575
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158731
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28172211
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_35</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158377
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158901
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_100</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158375
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159679
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_96</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158375
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158543
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_12</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158223
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158387
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28165889
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_7</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158413
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159155
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28305633
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_86</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158377
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28161307
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_31</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158899
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28165019
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_65</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158899
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28168255
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_93</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158899
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160121
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_36</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158307
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28165199
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_79</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158223
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158425
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28161725
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28163487
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_70</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158899
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28164349
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_115</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158899
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28163191
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_55</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158223
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158425
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28165231
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_2</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158377
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159419
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28162413
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_29</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158335
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28161105
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_57</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158575
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28165349
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_60</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158899
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159597
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_105</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158375
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158551
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_107</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158307
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158941
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_33</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158223
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158425
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28169019
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_94</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158223
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158425
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159065
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_19</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158223
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158425
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159211
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_112</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158413
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158733
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_85</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158755
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159365
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_10</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158307
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158961
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_24</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158575
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159487
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_84</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158413
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159155
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28170151
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_58</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28161395
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28166197
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_49</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158899
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160675
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_91</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158335
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159217
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_52</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158755
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28163519
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_1</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158223
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158425
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28163213
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_77</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158899
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28165075
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_48</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158335
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28164923
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_113</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158223
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158425
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28168101
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_39</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158689
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159315
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_0</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158575
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158731
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159411
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_104</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158405
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158615
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_42</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158223
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158425
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28170619
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_16</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158219
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28161151
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_103</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158375
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160795
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28172651
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_23</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158223
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158425
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28161325
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_110</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158223
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158425
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28162657
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_83</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158899
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159743
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_97</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158223
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158425
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28163425
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_22</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158689
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160997
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_13</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158377
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159419
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28162143
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_74</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158689
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159009
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_6</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158377
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159385
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_47</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158369
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160523
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_8</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158223
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158425
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28170017
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_05_31_1423203_50</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159289
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28165021
</commentlist>
</thread>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_05_31_1423203.20</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158375
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158543
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160795
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28172591
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28172651
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159679
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28161021
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158551
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158757
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_05_31_1423203.9</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158223
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158465
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158471
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158387
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28165889
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158425
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160767
---http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28162919
---http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28165575
---http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28162475
---http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28161739
---http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28170619
---http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28170071
---http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28161725
----http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28163487
---http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28163093
---http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28163435
---http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28163213
---http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28162379
---http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28168101
---http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28169019
---http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28164323
---http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28166463
---http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28170017
---http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28164935
---http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28164223
---http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28163845
---http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28161557
---http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28165315
---http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28162657
---http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28162767
----http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28169407
---http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28165231
---http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28163425
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158973
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28161325
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159211
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159065
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_05_31_1423203.7</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158369
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160523
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_05_31_1423203.5</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28161395
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28166197
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_05_31_1423203.18</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158405
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28161135
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158845
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158615
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159839
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_05_31_1423203.8</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158283
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158623
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_05_31_1423203.6</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159289
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28165021
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_05_31_1423203.19</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158219
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159073
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158747
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28174401
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28161151
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158743
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_05_31_1423203.12</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158899
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28168255
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159743
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28165019
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28165075
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160521
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159597
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28163191
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28164349
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160121
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160675
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_05_31_1423203.10</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158689
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28162415
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159009
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159315
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28188203
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28161003
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160997
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158871
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158969
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159117
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28163465
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_05_31_1423203.14</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158809
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28164933
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_05_31_1423203.3</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158331
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28162647
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_05_31_1423203.13</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160617
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_05_31_1423203.16</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158335
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28162313
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28164923
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159217
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158939
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159809
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28161105
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_05_31_1423203.11</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158307
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160417
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158819
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158941
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28165199
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160987
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158961
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_05_31_1423203.1</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158755
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159365
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159161
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28163519
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28165437
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_05_31_1423203.22</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158787
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_05_31_1423203.21</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160159
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28165035
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_05_31_1423203.4</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158785
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_05_31_1423203.17</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158413
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159155
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28305633
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28170151
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28175893
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159631
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158733
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158657
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158889
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_05_31_1423203.2</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158575
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158731
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159099
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28172211
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159411
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159763
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28165349
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158953
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160047
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159487
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28160557
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28164093
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_05_31_1423203.15</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158377
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159419
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28175869
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28162413
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28164399
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28162143
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28159385
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28161307
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28171657
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158901
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_05_31_1423203.0</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28158775
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28161343
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_05_31_1423203.28166225
</commentlist>
</conversation>
