<article>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#article09_11_24_2120246</id>
	<title>Haskell 2010 Announced</title>
	<author>kdawson</author>
	<datestamp>1259057100000</datestamp>
	<htmltext>paltemalte writes <i>"Simon Marlow has posted an <a href="http://www.haskell.org/pipermail/haskell/2009-November/021750.html">announcement of Haskell 2010</a>, a new revision of the <a href="http://www.haskell.org/">Haskell</a> purely functional programming language. Good news for everyone interested in SMP and concurrency programming."</i></htmltext>
<tokenext>paltemalte writes " Simon Marlow has posted an announcement of Haskell 2010 , a new revision of the Haskell purely functional programming language .
Good news for everyone interested in SMP and concurrency programming .
"</tokentext>
<sentencetext>paltemalte writes "Simon Marlow has posted an announcement of Haskell 2010, a new revision of the Haskell purely functional programming language.
Good news for everyone interested in SMP and concurrency programming.
"</sentencetext>
</article>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220256</id>
	<title>Re:Is it just me ?</title>
	<author>DragonWriter</author>
	<datestamp>1259064420000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><blockquote><div><p>I admit that a function with no side effects can ease making things thread safe, but are recursive style functional programming languages really used that much in "SMP and concurrency programming" nowadays.</p></div> </blockquote><p>If by "recursive style functional programming languages" you mean (more or less) functional programming languages that support tail call optimization so that tail calls, including self-recursive calls, are efficient, then the answer is "yes".</p><p>Besides Haskell, Erlang, for instance, is such a language , and concurrent applications are one of its main strengths.</p></div>
	</htmltext>
<tokenext>I admit that a function with no side effects can ease making things thread safe , but are recursive style functional programming languages really used that much in " SMP and concurrency programming " nowadays .
If by " recursive style functional programming languages " you mean ( more or less ) functional programming languages that support tail call optimization so that tail calls , including self-recursive calls , are efficient , then the answer is " yes " .Besides Haskell , Erlang , for instance , is such a language , and concurrent applications are one of its main strengths .</tokentext>
<sentencetext>I admit that a function with no side effects can ease making things thread safe, but are recursive style functional programming languages really used that much in "SMP and concurrency programming" nowadays.
If by "recursive style functional programming languages" you mean (more or less) functional programming languages that support tail call optimization so that tail calls, including self-recursive calls, are efficient, then the answer is "yes".Besides Haskell, Erlang, for instance, is such a language , and concurrent applications are one of its main strengths.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219458</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30222746</id>
	<title>Re:Concurrency?</title>
	<author>mandolin</author>
	<datestamp>1259083260000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>they have no mutable variables in the usual sense<nobr> <wbr></nobr>... You can't do this in C or Java because it might be necessary for one function to see a variable modified by another. </p></div><p>I think the key word here is "might".</p><p>Nothing prevents a C compiler from figuring out "int foo(int a) { return a + 2; }" is pure.  In fact gcc can do this to some extent; the relevant compiler flag (enabled by default w/optimization) is "-fipa-pure-const".</p><p>gcc also lets you specify the attribute 'const' to declare that a function is pure (in the sense that we're using it here).</p><p>Sure, it's coarse, and an afterthought, but it's also flexible.</p></div>
	</htmltext>
<tokenext>they have no mutable variables in the usual sense ... You ca n't do this in C or Java because it might be necessary for one function to see a variable modified by another .
I think the key word here is " might " .Nothing prevents a C compiler from figuring out " int foo ( int a ) { return a + 2 ; } " is pure .
In fact gcc can do this to some extent ; the relevant compiler flag ( enabled by default w/optimization ) is " -fipa-pure-const " .gcc also lets you specify the attribute 'const ' to declare that a function is pure ( in the sense that we 're using it here ) .Sure , it 's coarse , and an afterthought , but it 's also flexible .</tokentext>
<sentencetext>they have no mutable variables in the usual sense ... You can't do this in C or Java because it might be necessary for one function to see a variable modified by another.
I think the key word here is "might".Nothing prevents a C compiler from figuring out "int foo(int a) { return a + 2; }" is pure.
In fact gcc can do this to some extent; the relevant compiler flag (enabled by default w/optimization) is "-fipa-pure-const".gcc also lets you specify the attribute 'const' to declare that a function is pure (in the sense that we're using it here).Sure, it's coarse, and an afterthought, but it's also flexible.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220100</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30221640</id>
	<title>Gee</title>
	<author>Anonymous</author>
	<datestamp>1259073180000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext>How many languages does it take to tell Mrs. Cleaver how lovely she looks today?</htmltext>
<tokenext>How many languages does it take to tell Mrs. Cleaver how lovely she looks today ?</tokentext>
<sentencetext>How many languages does it take to tell Mrs. Cleaver how lovely she looks today?</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30225324</id>
	<title>Re:on haskell quicksort</title>
	<author>Goaway</author>
	<datestamp>1257173640000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>The fourth reason is that C is doing in-place array swaps.</p></div><p>And the ability to do that is the whole <em>reason</em> for quicksort. If you do quicksort without doing it in-place, you're just being silly.</p></div>
	</htmltext>
<tokenext>The fourth reason is that C is doing in-place array swaps.And the ability to do that is the whole reason for quicksort .
If you do quicksort without doing it in-place , you 're just being silly .</tokentext>
<sentencetext>The fourth reason is that C is doing in-place array swaps.And the ability to do that is the whole reason for quicksort.
If you do quicksort without doing it in-place, you're just being silly.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30221244</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30222212</id>
	<title>Re:Is it just me ?</title>
	<author>Anonymous</author>
	<datestamp>1259077920000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Functional languages do support iteration. It is just implemented as internal vs. external iteration. Both are valid forms and not unique to functional languages (e.g. Smalltalk used them). Side-effects are always necessary and must be handled and pure OO doesn't have anything inherently incompatible, just that the OO implementations that we use are far from pure.</p><p>You never get "past" Amdahl's Law, no matter how loosely you want to state it. A change in algorithms doesn't work around it, it just changes the variable values. Instead of fighting Amdahl's law head-on you must change your perspective to focus on Gustafson's law instead.</p></htmltext>
<tokenext>Functional languages do support iteration .
It is just implemented as internal vs. external iteration .
Both are valid forms and not unique to functional languages ( e.g .
Smalltalk used them ) .
Side-effects are always necessary and must be handled and pure OO does n't have anything inherently incompatible , just that the OO implementations that we use are far from pure.You never get " past " Amdahl 's Law , no matter how loosely you want to state it .
A change in algorithms does n't work around it , it just changes the variable values .
Instead of fighting Amdahl 's law head-on you must change your perspective to focus on Gustafson 's law instead .</tokentext>
<sentencetext>Functional languages do support iteration.
It is just implemented as internal vs. external iteration.
Both are valid forms and not unique to functional languages (e.g.
Smalltalk used them).
Side-effects are always necessary and must be handled and pure OO doesn't have anything inherently incompatible, just that the OO implementations that we use are far from pure.You never get "past" Amdahl's Law, no matter how loosely you want to state it.
A change in algorithms doesn't work around it, it just changes the variable values.
Instead of fighting Amdahl's law head-on you must change your perspective to focus on Gustafson's law instead.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219722</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219560</id>
	<title>But I'm lazy...</title>
	<author>nweaver</author>
	<datestamp>1259061180000</datestamp>
	<modclass>Funny</modclass>
	<modscore>5</modscore>
	<htmltext><p>So I don't think I'll look at the article until I actually need to program in Haskel....</p></htmltext>
<tokenext>So I do n't think I 'll look at the article until I actually need to program in Haskel... .</tokentext>
<sentencetext>So I don't think I'll look at the article until I actually need to program in Haskel....</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220176</id>
	<title>Re:Concurrency?</title>
	<author>xZgf6xHx2uhoAj9D</author>
	<datestamp>1259063940000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Yeah the revisions are really tiny (well except for FFI, which also doesn't relate to concurrency). I think the Slashdot poster was trying to say that Haskell in general is nice for concurrency, not these revisions specifically.
</p><p>With the exception of FFI, these revisions are dreadfully boring. It would be like if a new C standard came out that allowed you to write "floating" instead of just "float". That's about on par with the magnitude of the changes Haskell 2010 brings in<nobr> <wbr></nobr>:P</p></htmltext>
<tokenext>Yeah the revisions are really tiny ( well except for FFI , which also does n't relate to concurrency ) .
I think the Slashdot poster was trying to say that Haskell in general is nice for concurrency , not these revisions specifically .
With the exception of FFI , these revisions are dreadfully boring .
It would be like if a new C standard came out that allowed you to write " floating " instead of just " float " .
That 's about on par with the magnitude of the changes Haskell 2010 brings in : P</tokentext>
<sentencetext>Yeah the revisions are really tiny (well except for FFI, which also doesn't relate to concurrency).
I think the Slashdot poster was trying to say that Haskell in general is nice for concurrency, not these revisions specifically.
With the exception of FFI, these revisions are dreadfully boring.
It would be like if a new C standard came out that allowed you to write "floating" instead of just "float".
That's about on par with the magnitude of the changes Haskell 2010 brings in :P</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219580</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30224900</id>
	<title>Re:Is it just me ?</title>
	<author>sergueyz</author>
	<datestamp>1257169320000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><a href="http://shootout.alioth.debian.org/gp4/benchmark.php?test=threadring&amp;lang=all&amp;box=1" title="debian.org" rel="nofollow">Scala does not scale</a> [debian.org] comparing with Erlang/Haskell. F# also shouldn't, because it uses<nobr> <wbr></nobr>.Net (see C# up there).<p>Also, <a href="http://www.google.com/search?hl=en&amp;site=&amp;q=nested+data+parallelism&amp;btnG=Search" title="google.com" rel="nofollow">Nested Data Parallelism</a> [google.com] won't be available in programming languages sooner that in Haskell. And I look for NDP as an unique way to make heterogenous parallel environments work (those like IBM Cell BE, for example).</p></htmltext>
<tokenext>Scala does not scale [ debian.org ] comparing with Erlang/Haskell .
F # also should n't , because it uses .Net ( see C # up there ) .Also , Nested Data Parallelism [ google.com ] wo n't be available in programming languages sooner that in Haskell .
And I look for NDP as an unique way to make heterogenous parallel environments work ( those like IBM Cell BE , for example ) .</tokentext>
<sentencetext>Scala does not scale [debian.org] comparing with Erlang/Haskell.
F# also shouldn't, because it uses .Net (see C# up there).Also, Nested Data Parallelism [google.com] won't be available in programming languages sooner that in Haskell.
And I look for NDP as an unique way to make heterogenous parallel environments work (those like IBM Cell BE, for example).</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219722</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30223006</id>
	<title>Re:Not to sound like an ass, but...</title>
	<author>Anonymous</author>
	<datestamp>1259086440000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Check out "Fun with Functional Dependencies".  I think ExistentialQuantification is a better pattern for organizing code, but FunDeps can potentially improve run-time performance.</p></htmltext>
<tokenext>Check out " Fun with Functional Dependencies " .
I think ExistentialQuantification is a better pattern for organizing code , but FunDeps can potentially improve run-time performance .</tokentext>
<sentencetext>Check out "Fun with Functional Dependencies".
I think ExistentialQuantification is a better pattern for organizing code, but FunDeps can potentially improve run-time performance.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219938</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30224994</id>
	<title>Re:on haskell quicksort</title>
	<author>harry666t</author>
	<datestamp>1257170520000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Thank you for your explainations. I wasn't aware that the example I've used was the worst case. I think I'd better go educate myself a little more on algorithms and data structures<nobr> <wbr></nobr>:D</p></htmltext>
<tokenext>Thank you for your explainations .
I was n't aware that the example I 've used was the worst case .
I think I 'd better go educate myself a little more on algorithms and data structures : D</tokentext>
<sentencetext>Thank you for your explainations.
I wasn't aware that the example I've used was the worst case.
I think I'd better go educate myself a little more on algorithms and data structures :D</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30221244</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30221686</id>
	<title>Re:Is it just me ?</title>
	<author>Anonymous</author>
	<datestamp>1259073480000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext>Then why aren't the FP shops kicking as and taking names?  They should be leading in every segment of the market if what you wrote is true.

It isn't.  This is because FP isn't this magical pixie dust that so many claim it to be.  That the compilers produce extremely slow code doesn't help matters.  It really doesn't matter if your code runs on 8 processors if the C version is 10x faster on a single core.</htmltext>
<tokenext>Then why are n't the FP shops kicking as and taking names ?
They should be leading in every segment of the market if what you wrote is true .
It is n't .
This is because FP is n't this magical pixie dust that so many claim it to be .
That the compilers produce extremely slow code does n't help matters .
It really does n't matter if your code runs on 8 processors if the C version is 10x faster on a single core .</tokentext>
<sentencetext>Then why aren't the FP shops kicking as and taking names?
They should be leading in every segment of the market if what you wrote is true.
It isn't.
This is because FP isn't this magical pixie dust that so many claim it to be.
That the compilers produce extremely slow code doesn't help matters.
It really doesn't matter if your code runs on 8 processors if the C version is 10x faster on a single core.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219722</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30221082</id>
	<title>Re:Is it just me ?</title>
	<author>ascari</author>
	<datestamp>1259068980000</datestamp>
	<modclass>Funny</modclass>
	<modscore>5</modscore>
	<htmltext>"recursive style" Definition: Curse. And then curse again.</htmltext>
<tokenext>" recursive style " Definition : Curse .
And then curse again .</tokentext>
<sentencetext>"recursive style" Definition: Curse.
And then curse again.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219832</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219832</id>
	<title>Re:Is it just me ?</title>
	<author>Anonymous</author>
	<datestamp>1259062440000</datestamp>
	<modclass>Informativ</modclass>
	<modscore>3</modscore>
	<htmltext><p>I'm not sure what you mean by "recursive style", but the biggest commercial users of functional programming languages tend to be companies behind high-traffic websites that need to handle a lot of concurrent requests. Facebook developed their real-time chat application in Erlang, for instance, and Twitter uses Scala to handle its message queue.</p></htmltext>
<tokenext>I 'm not sure what you mean by " recursive style " , but the biggest commercial users of functional programming languages tend to be companies behind high-traffic websites that need to handle a lot of concurrent requests .
Facebook developed their real-time chat application in Erlang , for instance , and Twitter uses Scala to handle its message queue .</tokentext>
<sentencetext>I'm not sure what you mean by "recursive style", but the biggest commercial users of functional programming languages tend to be companies behind high-traffic websites that need to handle a lot of concurrent requests.
Facebook developed their real-time chat application in Erlang, for instance, and Twitter uses Scala to handle its message queue.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219458</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30221120</id>
	<title>Re:Is it just me ?</title>
	<author>Anonymous</author>
	<datestamp>1259069160000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>This is comment is not +5 insightful its incorrect.  You don't understand Ahmdal's Law.  Any algorithm that is fundamentally iterative, in that in relies on the results of the last iteration, will quickly reach an upper limit of improvement by making it more multithreaded and adding more processors.  Many, many algorithms are like this.  Don't believe me? Just try parallelizing Dijkstras...</p></htmltext>
<tokenext>This is comment is not + 5 insightful its incorrect .
You do n't understand Ahmdal 's Law .
Any algorithm that is fundamentally iterative , in that in relies on the results of the last iteration , will quickly reach an upper limit of improvement by making it more multithreaded and adding more processors .
Many , many algorithms are like this .
Do n't believe me ?
Just try parallelizing Dijkstras.. .</tokentext>
<sentencetext>This is comment is not +5 insightful its incorrect.
You don't understand Ahmdal's Law.
Any algorithm that is fundamentally iterative, in that in relies on the results of the last iteration, will quickly reach an upper limit of improvement by making it more multithreaded and adding more processors.
Many, many algorithms are like this.
Don't believe me?
Just try parallelizing Dijkstras...</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219722</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219890</id>
	<title>NoNPlusKPatterns</title>
	<author>harry666t</author>
	<datestamp>1259062740000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>NoNPlusKPatterns... Seems that they're finally banned.</p><p><a href="http://www.mail-archive.com/haskell@haskell.org/msg01261.html" title="mail-archive.com">http://www.mail-archive.com/haskell@haskell.org/msg01261.html</a> [mail-archive.com]</p></htmltext>
<tokenext>NoNPlusKPatterns... Seems that they 're finally banned.http : //www.mail-archive.com/haskell @ haskell.org/msg01261.html [ mail-archive.com ]</tokentext>
<sentencetext>NoNPlusKPatterns... Seems that they're finally banned.http://www.mail-archive.com/haskell@haskell.org/msg01261.html [mail-archive.com]</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219458</id>
	<title>Is it just me ?</title>
	<author>Anonymous</author>
	<datestamp>1259060700000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>3</modscore>
	<htmltext><p>I admit that a function with no side effects can ease making things thread safe, but are recursive style functional programming languages really used that much in "SMP and concurrency programming" nowadays. I wrote some code in that category but I never envisioned a functional programming language would suit the job. Am I the only one ?<nobr> <wbr></nobr>;-))</p><p>Thanks for your replies,</p></htmltext>
<tokenext>I admit that a function with no side effects can ease making things thread safe , but are recursive style functional programming languages really used that much in " SMP and concurrency programming " nowadays .
I wrote some code in that category but I never envisioned a functional programming language would suit the job .
Am I the only one ?
; - ) ) Thanks for your replies,</tokentext>
<sentencetext>I admit that a function with no side effects can ease making things thread safe, but are recursive style functional programming languages really used that much in "SMP and concurrency programming" nowadays.
I wrote some code in that category but I never envisioned a functional programming language would suit the job.
Am I the only one ?
;-))Thanks for your replies,</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219580</id>
	<title>Concurrency?</title>
	<author>Anonymous</author>
	<datestamp>1259061300000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I skimmed through the revisions, and I don't see how they relate to concurrency (caveat I'm a Haskell newbie). Maybe someone can enlighten me.</p></htmltext>
<tokenext>I skimmed through the revisions , and I do n't see how they relate to concurrency ( caveat I 'm a Haskell newbie ) .
Maybe someone can enlighten me .</tokentext>
<sentencetext>I skimmed through the revisions, and I don't see how they relate to concurrency (caveat I'm a Haskell newbie).
Maybe someone can enlighten me.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220332</id>
	<title>Re:Is it just me ?</title>
	<author>harry666t</author>
	<datestamp>1259064720000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>2</modscore>
	<htmltext><p>Except that<br>1. Slashdot thought you're writing HTML and ate half of your code<br>2. Put it into a module and load in ghci, then try something like "qsort [1..10000]". Watch the slowness.<br>3. The efficient implementation in Haskell uses iteration and is 100 times less readable than equivalent code in C.</p><p>I really like Haskell, but this is not the best example of its strenghts.</p></htmltext>
<tokenext>Except that1 .
Slashdot thought you 're writing HTML and ate half of your code2 .
Put it into a module and load in ghci , then try something like " qsort [ 1..10000 ] " .
Watch the slowness.3 .
The efficient implementation in Haskell uses iteration and is 100 times less readable than equivalent code in C.I really like Haskell , but this is not the best example of its strenghts .</tokentext>
<sentencetext>Except that1.
Slashdot thought you're writing HTML and ate half of your code2.
Put it into a module and load in ghci, then try something like "qsort [1..10000]".
Watch the slowness.3.
The efficient implementation in Haskell uses iteration and is 100 times less readable than equivalent code in C.I really like Haskell, but this is not the best example of its strenghts.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220086</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220566</id>
	<title>Re:Amazing day...</title>
	<author>Anonymous</author>
	<datestamp>1259065860000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>You're absolutly right. Who needs anything besides BASIC.</p></htmltext>
<tokenext>You 're absolutly right .
Who needs anything besides BASIC .</tokentext>
<sentencetext>You're absolutly right.
Who needs anything besides BASIC.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219482</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219482</id>
	<title>Amazing day...</title>
	<author>Anonymous</author>
	<datestamp>1259060760000</datestamp>
	<modclass>Funny</modclass>
	<modscore>4</modscore>
	<htmltext>And all three of its users are overjoyed.</htmltext>
<tokenext>And all three of its users are overjoyed .</tokentext>
<sentencetext>And all three of its users are overjoyed.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220700</id>
	<title>Re:Amazing day...</title>
	<author>Anonymous</author>
	<datestamp>1259066520000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Yeah, and you may thank them when attached to a heart-lung machine that was NOT written in C/C++ instead, because B. Curry&rsquo;s gonna kick yo ass with that attitude!<nobr> <wbr></nobr>;P</p></htmltext>
<tokenext>Yeah , and you may thank them when attached to a heart-lung machine that was NOT written in C/C + + instead , because B. Curry    s gon na kick yo ass with that attitude !
; P</tokentext>
<sentencetext>Yeah, and you may thank them when attached to a heart-lung machine that was NOT written in C/C++ instead, because B. Curry’s gonna kick yo ass with that attitude!
;P</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219482</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30222742</id>
	<title>Re:Is it just me ?</title>
	<author>Anonymous</author>
	<datestamp>1259083140000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext>Basically, a subset of what Scheme had 30 years ago in the MIT AI lab.</htmltext>
<tokenext>Basically , a subset of what Scheme had 30 years ago in the MIT AI lab .</tokentext>
<sentencetext>Basically, a subset of what Scheme had 30 years ago in the MIT AI lab.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220672</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219556</id>
	<title>Reminds me of Life of Brian...</title>
	<author>migla</author>
	<datestamp>1259061180000</datestamp>
	<modclass>Funny</modclass>
	<modscore>2</modscore>
	<htmltext><p>"The current committee is still discussing how to go about finding a new committee"</p><p>A fitting name for this Haskell programming language might have been "Python" hadn't it all ready been taken.</p></htmltext>
<tokenext>" The current committee is still discussing how to go about finding a new committee " A fitting name for this Haskell programming language might have been " Python " had n't it all ready been taken .</tokentext>
<sentencetext>"The current committee is still discussing how to go about finding a new committee"A fitting name for this Haskell programming language might have been "Python" hadn't it all ready been taken.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220354</id>
	<title>Re:Amazing day...</title>
	<author>Anonymous</author>
	<datestamp>1259064840000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>ever been to reddit? proggit is full of haskellers</p></htmltext>
<tokenext>ever been to reddit ?
proggit is full of haskellers</tokentext>
<sentencetext>ever been to reddit?
proggit is full of haskellers</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219482</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219722</id>
	<title>Re:Is it just me ?</title>
	<author>rjh</author>
	<datestamp>1259061900000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>4</modscore>
	<htmltext><p>Functional languages are enjoying an enormous renaissance in the field of multithread, multicore and/or multiprocessor environments.</p><p>There are a few really major obstacles to doing multi-* well.  The major theoretical one is Amdahl's Law, which puts some extreme limits on how much multi-* can help you.  The major practical one is our current obsession with side-effect languages.  We need major theoretical advancements to get past Amdahl's Law (if, in fact, it can be gotten past at all).  Functional programming is a great way to get past side-effect-based programming, though.</p><p>In a proper functional language, there is no such thing as iteration.  There can't be.  The instant you say, "each time through the loop, increment the counter, and as soon as it hits this certain value stop," you have stopped programming in a functional style.</p><p>As an example of some really cool concurrent languages that emphasize recursion and functional programming, look at Clojure, Scala, Erlang and F#.  All of these languages provide iteration and other side effect techniques if you really need them -- but all of these languages emphasize recursion.</p></htmltext>
<tokenext>Functional languages are enjoying an enormous renaissance in the field of multithread , multicore and/or multiprocessor environments.There are a few really major obstacles to doing multi- * well .
The major theoretical one is Amdahl 's Law , which puts some extreme limits on how much multi- * can help you .
The major practical one is our current obsession with side-effect languages .
We need major theoretical advancements to get past Amdahl 's Law ( if , in fact , it can be gotten past at all ) .
Functional programming is a great way to get past side-effect-based programming , though.In a proper functional language , there is no such thing as iteration .
There ca n't be .
The instant you say , " each time through the loop , increment the counter , and as soon as it hits this certain value stop , " you have stopped programming in a functional style.As an example of some really cool concurrent languages that emphasize recursion and functional programming , look at Clojure , Scala , Erlang and F # .
All of these languages provide iteration and other side effect techniques if you really need them -- but all of these languages emphasize recursion .</tokentext>
<sentencetext>Functional languages are enjoying an enormous renaissance in the field of multithread, multicore and/or multiprocessor environments.There are a few really major obstacles to doing multi-* well.
The major theoretical one is Amdahl's Law, which puts some extreme limits on how much multi-* can help you.
The major practical one is our current obsession with side-effect languages.
We need major theoretical advancements to get past Amdahl's Law (if, in fact, it can be gotten past at all).
Functional programming is a great way to get past side-effect-based programming, though.In a proper functional language, there is no such thing as iteration.
There can't be.
The instant you say, "each time through the loop, increment the counter, and as soon as it hits this certain value stop," you have stopped programming in a functional style.As an example of some really cool concurrent languages that emphasize recursion and functional programming, look at Clojure, Scala, Erlang and F#.
All of these languages provide iteration and other side effect techniques if you really need them -- but all of these languages emphasize recursion.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219458</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30221244</id>
	<title>on haskell quicksort</title>
	<author>j1m+5n0w</author>
	<datestamp>1259069940000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I agree it's not always the best example, but there are four reasons why "qsort [1..10000]" is slow, and you can address three of them without writing something that's "100 times less readable than C".

</p><p>The first problem is that naive quicksort on an already-sorted list/array is O(N^2).  The fix is to grab an element out of the middle and use that as your pivot.  That alone will make qsort far faster.  (I tried it.*)  The resulting code is, of course, a bit messier.

</p><p>Secondly, the qsort function has no type signature, so it will default to the most polymorphic implementation, which is something like qsort<nobr> <wbr></nobr>:: Num a -&gt; [a] -&gt; [a].  Typing "qsort [1..10000] probably (though I'm not sure, it's a ghci-specific thing) defaults to using Integer, which is less efficient than a machine Int.  If you constrain the type signature the code will be faster.

</p><p>Thirdly, you're using ghci.  Code compiled with "ghc -O2" is far faster.  (Be sure not forget that -O2, it make the code about 10x faster.)

</p><p>The fourth reason is that C is doing in-place array swaps.  (You can do the same thing in Haskell using the ST monad if you really want to.  I don't think the result will be "100 times less readable", but it will be fairly ugly compared to the pure version.  There are a couple such implementation <a href="http://www.haskell.org/haskellwiki/Introduction/Direct\_Translation" title="haskell.org">here</a> [haskell.org].)  Whether doing quicksort with lists is good enough really depends on what you're doing.

</p><p>* Quicksort modified with a swap, then mangled by slashdot:</p><blockquote><div><p>module Qsort
where

qsort [] = []
qsort xs =
 let n = length xs
 in
   if n &gt; 100
   then
     let split = n `div` 2
         (a,b) = splitAt split xs
     in \_qsort $ (xs!!split) : (a ++ (tail b))
   else
     \_qsort xs

\_qsort [] = []
\_qsort (x:xs) =
  qsort (filter (= x) xs)</p></div>

</blockquote></div>
	</htmltext>
<tokenext>I agree it 's not always the best example , but there are four reasons why " qsort [ 1..10000 ] " is slow , and you can address three of them without writing something that 's " 100 times less readable than C " .
The first problem is that naive quicksort on an already-sorted list/array is O ( N ^ 2 ) .
The fix is to grab an element out of the middle and use that as your pivot .
That alone will make qsort far faster .
( I tried it .
* ) The resulting code is , of course , a bit messier .
Secondly , the qsort function has no type signature , so it will default to the most polymorphic implementation , which is something like qsort : : Num a - &gt; [ a ] - &gt; [ a ] .
Typing " qsort [ 1..10000 ] probably ( though I 'm not sure , it 's a ghci-specific thing ) defaults to using Integer , which is less efficient than a machine Int .
If you constrain the type signature the code will be faster .
Thirdly , you 're using ghci .
Code compiled with " ghc -O2 " is far faster .
( Be sure not forget that -O2 , it make the code about 10x faster .
) The fourth reason is that C is doing in-place array swaps .
( You can do the same thing in Haskell using the ST monad if you really want to .
I do n't think the result will be " 100 times less readable " , but it will be fairly ugly compared to the pure version .
There are a couple such implementation here [ haskell.org ] .
) Whether doing quicksort with lists is good enough really depends on what you 're doing .
* Quicksort modified with a swap , then mangled by slashdot : module Qsort where qsort [ ] = [ ] qsort xs = let n = length xs in if n &gt; 100 then let split = n ` div ` 2 ( a,b ) = splitAt split xs in \ _qsort $ ( xs !
! split ) : ( a + + ( tail b ) ) else \ _qsort xs \ _qsort [ ] = [ ] \ _qsort ( x : xs ) = qsort ( filter ( = x ) xs )</tokentext>
<sentencetext>I agree it's not always the best example, but there are four reasons why "qsort [1..10000]" is slow, and you can address three of them without writing something that's "100 times less readable than C".
The first problem is that naive quicksort on an already-sorted list/array is O(N^2).
The fix is to grab an element out of the middle and use that as your pivot.
That alone will make qsort far faster.
(I tried it.
*)  The resulting code is, of course, a bit messier.
Secondly, the qsort function has no type signature, so it will default to the most polymorphic implementation, which is something like qsort :: Num a -&gt; [a] -&gt; [a].
Typing "qsort [1..10000] probably (though I'm not sure, it's a ghci-specific thing) defaults to using Integer, which is less efficient than a machine Int.
If you constrain the type signature the code will be faster.
Thirdly, you're using ghci.
Code compiled with "ghc -O2" is far faster.
(Be sure not forget that -O2, it make the code about 10x faster.
)

The fourth reason is that C is doing in-place array swaps.
(You can do the same thing in Haskell using the ST monad if you really want to.
I don't think the result will be "100 times less readable", but it will be fairly ugly compared to the pure version.
There are a couple such implementation here [haskell.org].
)  Whether doing quicksort with lists is good enough really depends on what you're doing.
* Quicksort modified with a swap, then mangled by slashdot:module Qsort
where

qsort [] = []
qsort xs =
 let n = length xs
 in
   if n &gt; 100
   then
     let split = n `div` 2
         (a,b) = splitAt split xs
     in \_qsort $ (xs!
!split) : (a ++ (tail b))
   else
     \_qsort xs

\_qsort [] = []
\_qsort (x:xs) =
  qsort (filter (= x) xs)


	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220332</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30223642</id>
	<title>Re:Oh, be still my heart....</title>
	<author>Anonymous</author>
	<datestamp>1257152880000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Is that you, bonch?</p></htmltext>
<tokenext>Is that you , bonch ?</tokentext>
<sentencetext>Is that you, bonch?</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219586</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30222040</id>
	<title>Re:Is it just me ?</title>
	<author>microbox</author>
	<datestamp>1259076240000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><i>The idea is that you can split up the program in parallel tasks in a fully automated way. If you as a programmer even have to think about parallelizing, I&rsquo;m sorry, but then your compiler is &ldquo;doin&rsquo; it wrong&rdquo; and your languages is from the stone age. </i> <br>
<br>
This is not true in high-performance computing. If you don't want your CPU spinning its wheels on locks and cache misses, then you need to go quite low level -- and really think about the data structures you're using, and how to parallise tasks with next to no interthread communication.</htmltext>
<tokenext>The idea is that you can split up the program in parallel tasks in a fully automated way .
If you as a programmer even have to think about parallelizing , I    m sorry , but then your compiler is    doin    it wrong    and your languages is from the stone age .
This is not true in high-performance computing .
If you do n't want your CPU spinning its wheels on locks and cache misses , then you need to go quite low level -- and really think about the data structures you 're using , and how to parallise tasks with next to no interthread communication .</tokentext>
<sentencetext>The idea is that you can split up the program in parallel tasks in a fully automated way.
If you as a programmer even have to think about parallelizing, I’m sorry, but then your compiler is “doin’ it wrong” and your languages is from the stone age.
This is not true in high-performance computing.
If you don't want your CPU spinning its wheels on locks and cache misses, then you need to go quite low level -- and really think about the data structures you're using, and how to parallise tasks with next to no interthread communication.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220672</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30222518</id>
	<title>Ward, don't be too hard on the Beaver</title>
	<author>unitron</author>
	<datestamp>1259080920000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>The revision to which I look forward is the hack that causes it to make very impolite comments to Mrs. Cleaver.</p></htmltext>
<tokenext>The revision to which I look forward is the hack that causes it to make very impolite comments to Mrs. Cleaver .</tokentext>
<sentencetext>The revision to which I look forward is the hack that causes it to make very impolite comments to Mrs. Cleaver.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30229664</id>
	<title>Re:Haskell cannot do in-place qsort</title>
	<author>j1m+5n0w</author>
	<datestamp>1257194820000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Rather than type what I wrote in a similar thread again, I'll just link to it <a href="http://developers.slashdot.org/comments.pl?sid=1456030&amp;cid=30221244" title="slashdot.org">here</a> [slashdot.org].

</p><p>Summary: qsort [1..10000] is slow not so much because it isn't an in-place sort, but because naive quicksort on an already-sorted list is O(N^2) rather than O(NlogN).  If you use an element from the middle of the list as the pivot instead of the first element, it performs much better.

</p><p>As the other reply already stated, you can do in-place quicksort in Haskell by using the ST monad, if that's really what you want.</p></htmltext>
<tokenext>Rather than type what I wrote in a similar thread again , I 'll just link to it here [ slashdot.org ] .
Summary : qsort [ 1..10000 ] is slow not so much because it is n't an in-place sort , but because naive quicksort on an already-sorted list is O ( N ^ 2 ) rather than O ( NlogN ) .
If you use an element from the middle of the list as the pivot instead of the first element , it performs much better .
As the other reply already stated , you can do in-place quicksort in Haskell by using the ST monad , if that 's really what you want .</tokentext>
<sentencetext>Rather than type what I wrote in a similar thread again, I'll just link to it here [slashdot.org].
Summary: qsort [1..10000] is slow not so much because it isn't an in-place sort, but because naive quicksort on an already-sorted list is O(N^2) rather than O(NlogN).
If you use an element from the middle of the list as the pivot instead of the first element, it performs much better.
As the other reply already stated, you can do in-place quicksort in Haskell by using the ST monad, if that's really what you want.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30224116</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30222008</id>
	<title>Re:Is it just me ?</title>
	<author>Anonymous</author>
	<datestamp>1259076000000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p><div class="quote"><p> You won&rsquo;t expect to sit in a spaceship and drive it like your car too, would you?</p></div><p>Why not?</p><p>As the pilot, my wishes are <i>simple</i>: I want to move up and down and backward and forward. Why shouldn't the system abstract complex functionality to allow me to do this easily?</p><p>Assembly code is much more difficult than Haskell. Are you suggesting it should be otherwise?</p></div>
	</htmltext>
<tokenext>You won    t expect to sit in a spaceship and drive it like your car too , would you ? Why not ? As the pilot , my wishes are simple : I want to move up and down and backward and forward .
Why should n't the system abstract complex functionality to allow me to do this easily ? Assembly code is much more difficult than Haskell .
Are you suggesting it should be otherwise ?</tokentext>
<sentencetext> You won’t expect to sit in a spaceship and drive it like your car too, would you?Why not?As the pilot, my wishes are simple: I want to move up and down and backward and forward.
Why shouldn't the system abstract complex functionality to allow me to do this easily?Assembly code is much more difficult than Haskell.
Are you suggesting it should be otherwise?
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220672</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220246</id>
	<title>Re:Is it just me ?</title>
	<author>arevos</author>
	<datestamp>1259064360000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>&gt; I'm not sure what you mean by "recursive style",</p><p>Look at Quicksort in Haskell<nobr> <wbr></nobr>:</p><p>qsort []     = []<br>qsort (x:xs) = qsort (filter (= x) xs)</p><p>This is what I mean, no loops, recursion.</p></div><p>Well, all functional programming languages use recursion, so "recursive style functional programming languages" is a bit redundant<nobr> <wbr></nobr>:)</p></div>
	</htmltext>
<tokenext>&gt; I 'm not sure what you mean by " recursive style " ,Look at Quicksort in Haskell : qsort [ ] = [ ] qsort ( x : xs ) = qsort ( filter ( = x ) xs ) This is what I mean , no loops , recursion.Well , all functional programming languages use recursion , so " recursive style functional programming languages " is a bit redundant : )</tokentext>
<sentencetext>&gt; I'm not sure what you mean by "recursive style",Look at Quicksort in Haskell :qsort []     = []qsort (x:xs) = qsort (filter (= x) xs)This is what I mean, no loops, recursion.Well, all functional programming languages use recursion, so "recursive style functional programming languages" is a bit redundant :)
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220086</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30222312</id>
	<title>Re:Concurrency?</title>
	<author>shutdown -p now</author>
	<datestamp>1259078760000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>Haskell, along with the ML family of languages, also has an amazing type checker that is waaay more sophisticated than most other languages. I think most people who've played around with these languages do start to feel that often "If it compiles, it's bug-free". Obviously that's not something you can rely on, since the compiler can't know what you meant to do. But it is true that the type system is *way* more useful at detecting bugs at compile-time than for any conventional language I've used.</p></div><p>Actually, I dare say that Haskell type system is in fact a much bigger deal than its purity or laziness. Type classes are an awesome generalization of OO interfaces that let one define virtually arbitrary operators in a generic way, and then define generic algorithms using those operators, in an entirely type-safe way (and not using the C++ template model of "macros with a  quick sanity check at declaration point and horrible error messages if anything goes wrong later"). They can be used to fully emulate conventional OO in fact. Then there are <a href="http://en.wikipedia.org/wiki/Kind\_(type\_theory)" title="wikipedia.org">higher-order types</a> [wikipedia.org], which let you reuse operations on types just as you use functions to reuse operations on values.</p><p>Not to forget GHC extensions to Haskell, which let you control how exactly types are generalized - to consider what this means, try defining a generic function in C++, Java or C# that takes a collection of objects, which must all be instances of any class C implementing interface I - but they must all be instances of that same class (and not, say, some instances of C1 and some instances of C2, both implementing I).</p></div>
	</htmltext>
<tokenext>Haskell , along with the ML family of languages , also has an amazing type checker that is waaay more sophisticated than most other languages .
I think most people who 've played around with these languages do start to feel that often " If it compiles , it 's bug-free " .
Obviously that 's not something you can rely on , since the compiler ca n't know what you meant to do .
But it is true that the type system is * way * more useful at detecting bugs at compile-time than for any conventional language I 've used.Actually , I dare say that Haskell type system is in fact a much bigger deal than its purity or laziness .
Type classes are an awesome generalization of OO interfaces that let one define virtually arbitrary operators in a generic way , and then define generic algorithms using those operators , in an entirely type-safe way ( and not using the C + + template model of " macros with a quick sanity check at declaration point and horrible error messages if anything goes wrong later " ) .
They can be used to fully emulate conventional OO in fact .
Then there are higher-order types [ wikipedia.org ] , which let you reuse operations on types just as you use functions to reuse operations on values.Not to forget GHC extensions to Haskell , which let you control how exactly types are generalized - to consider what this means , try defining a generic function in C + + , Java or C # that takes a collection of objects , which must all be instances of any class C implementing interface I - but they must all be instances of that same class ( and not , say , some instances of C1 and some instances of C2 , both implementing I ) .</tokentext>
<sentencetext>Haskell, along with the ML family of languages, also has an amazing type checker that is waaay more sophisticated than most other languages.
I think most people who've played around with these languages do start to feel that often "If it compiles, it's bug-free".
Obviously that's not something you can rely on, since the compiler can't know what you meant to do.
But it is true that the type system is *way* more useful at detecting bugs at compile-time than for any conventional language I've used.Actually, I dare say that Haskell type system is in fact a much bigger deal than its purity or laziness.
Type classes are an awesome generalization of OO interfaces that let one define virtually arbitrary operators in a generic way, and then define generic algorithms using those operators, in an entirely type-safe way (and not using the C++ template model of "macros with a  quick sanity check at declaration point and horrible error messages if anything goes wrong later").
They can be used to fully emulate conventional OO in fact.
Then there are higher-order types [wikipedia.org], which let you reuse operations on types just as you use functions to reuse operations on values.Not to forget GHC extensions to Haskell, which let you control how exactly types are generalized - to consider what this means, try defining a generic function in C++, Java or C# that takes a collection of objects, which must all be instances of any class C implementing interface I - but they must all be instances of that same class (and not, say, some instances of C1 and some instances of C2, both implementing I).
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220100</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30222080</id>
	<title>Re:Oh, be still my heart....</title>
	<author>Anonymous</author>
	<datestamp>1259076600000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Masturbation can be fun.</p></htmltext>
<tokenext>Masturbation can be fun .</tokentext>
<sentencetext>Masturbation can be fun.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219586</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30224916</id>
	<title>Re:Amazing day...</title>
	<author>Anonymous</author>
	<datestamp>1257169560000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext>Hax my dead dog.</htmltext>
<tokenext>Hax my dead dog .</tokentext>
<sentencetext>Hax my dead dog.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220354</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220100</id>
	<title>Re:Concurrency?</title>
	<author>Lemming Mark</author>
	<datestamp>1259063700000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>4</modscore>
	<htmltext><p>Well, pure functional languages are (potentially) good for concurrency in general.  Because they have no mutable variables in the usual sense, it doesn't actually matter what order functions are evaluated in (other than the fact that callers cannot continue until their callees return).  You can't do this in C or Java because it might be necessary for one function to see a variable modified by another.  In a functional language, any dependencies are explicit call-return relationships (well, ish, they typically do have some non-functional constructs otherwise it's hard to do IO!), so in principle it's quite easy to split up a program's work across multiple CPUs (or machines) and not worry about whether they need to talk to each other.</p><p>Haskell, along with the ML family of languages, also has an amazing type checker that is waaay more sophisticated than most other languages.  I think most people who've played around with these languages do start to feel that often "If it compiles, it's bug-free".  Obviously that's not something you can rely on, since the compiler can't know what you meant to do.  But it is true that the type system is *way* more useful at detecting bugs at compile-time than for any conventional language I've used.</p></htmltext>
<tokenext>Well , pure functional languages are ( potentially ) good for concurrency in general .
Because they have no mutable variables in the usual sense , it does n't actually matter what order functions are evaluated in ( other than the fact that callers can not continue until their callees return ) .
You ca n't do this in C or Java because it might be necessary for one function to see a variable modified by another .
In a functional language , any dependencies are explicit call-return relationships ( well , ish , they typically do have some non-functional constructs otherwise it 's hard to do IO !
) , so in principle it 's quite easy to split up a program 's work across multiple CPUs ( or machines ) and not worry about whether they need to talk to each other.Haskell , along with the ML family of languages , also has an amazing type checker that is waaay more sophisticated than most other languages .
I think most people who 've played around with these languages do start to feel that often " If it compiles , it 's bug-free " .
Obviously that 's not something you can rely on , since the compiler ca n't know what you meant to do .
But it is true that the type system is * way * more useful at detecting bugs at compile-time than for any conventional language I 've used .</tokentext>
<sentencetext>Well, pure functional languages are (potentially) good for concurrency in general.
Because they have no mutable variables in the usual sense, it doesn't actually matter what order functions are evaluated in (other than the fact that callers cannot continue until their callees return).
You can't do this in C or Java because it might be necessary for one function to see a variable modified by another.
In a functional language, any dependencies are explicit call-return relationships (well, ish, they typically do have some non-functional constructs otherwise it's hard to do IO!
), so in principle it's quite easy to split up a program's work across multiple CPUs (or machines) and not worry about whether they need to talk to each other.Haskell, along with the ML family of languages, also has an amazing type checker that is waaay more sophisticated than most other languages.
I think most people who've played around with these languages do start to feel that often "If it compiles, it's bug-free".
Obviously that's not something you can rely on, since the compiler can't know what you meant to do.
But it is true that the type system is *way* more useful at detecting bugs at compile-time than for any conventional language I've used.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219580</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220086</id>
	<title>Re:Is it just me ?</title>
	<author>ls671</author>
	<datestamp>1259063640000</datestamp>
	<modclass>Informativ</modclass>
	<modscore>3</modscore>
	<htmltext><p>&gt; I'm not sure what you mean by "recursive style",</p><p>Look at Quicksort in Haskell :</p><p>qsort []     = []<br>qsort (x:xs) = qsort (filter (= x) xs)</p><p>This is what I mean, no loops, recursion. I used Prolog and ML to solve logic problems and it is pretty handy. Prolog is especially suited for solving logic problems ( "logic programming" ).</p></htmltext>
<tokenext>&gt; I 'm not sure what you mean by " recursive style " ,Look at Quicksort in Haskell : qsort [ ] = [ ] qsort ( x : xs ) = qsort ( filter ( = x ) xs ) This is what I mean , no loops , recursion .
I used Prolog and ML to solve logic problems and it is pretty handy .
Prolog is especially suited for solving logic problems ( " logic programming " ) .</tokentext>
<sentencetext>&gt; I'm not sure what you mean by "recursive style",Look at Quicksort in Haskell :qsort []     = []qsort (x:xs) = qsort (filter (= x) xs)This is what I mean, no loops, recursion.
I used Prolog and ML to solve logic problems and it is pretty handy.
Prolog is especially suited for solving logic problems ( "logic programming" ).</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219832</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220432</id>
	<title>Re:Is it just me ?</title>
	<author>ls671</author>
	<datestamp>1259065200000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Almost all programming languages support recursion so recursion is recursively redundant !<nobr> <wbr></nobr>;-))</p></htmltext>
<tokenext>Almost all programming languages support recursion so recursion is recursively redundant !
; - ) )</tokentext>
<sentencetext>Almost all programming languages support recursion so recursion is recursively redundant !
;-))</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220246</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30231598</id>
	<title>Re:Haskell cannot do in-place qsort</title>
	<author>Abcd1234</author>
	<datestamp>1257163380000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Of course it can, why not?  Haskell *does* allow modeling stateful computations, you just have to encapsulate it in a Monad.  So break out an ST Monad, do your in-place sort using an array, and voila, you're done.</p></htmltext>
<tokenext>Of course it can , why not ?
Haskell * does * allow modeling stateful computations , you just have to encapsulate it in a Monad .
So break out an ST Monad , do your in-place sort using an array , and voila , you 're done .</tokentext>
<sentencetext>Of course it can, why not?
Haskell *does* allow modeling stateful computations, you just have to encapsulate it in a Monad.
So break out an ST Monad, do your in-place sort using an array, and voila, you're done.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30224116</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30224116</id>
	<title>Haskell cannot do in-place qsort</title>
	<author>Anonymous</author>
	<datestamp>1257158820000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Can it; I think not. It's incredibly cool to write qsort in just 2 lines of code, but it's incredibly slow.</p></htmltext>
<tokenext>Can it ; I think not .
It 's incredibly cool to write qsort in just 2 lines of code , but it 's incredibly slow .</tokentext>
<sentencetext>Can it; I think not.
It's incredibly cool to write qsort in just 2 lines of code, but it's incredibly slow.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30221068</id>
	<title>Re:Is it just me ?</title>
	<author>Anonymous</author>
	<datestamp>1259068860000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p><div class="quote"><p>In a proper functional language, there is no such thing as iteration.  There can't be.  The instant you say, "each time through the loop, increment the counter, and as soon as it hits this certain value stop," you have stopped programming in a functional style.</p></div><p>Recursion basically does the same thing, albeit through function calls and argument passing. The difference is that it is "cleaner" because it's incredibly simple, and because there are no state changes. In Lisp languages you can just build your own looping constructs that use recursion under the hood, and get the best of both worlds.<br> <br>Of course the Lisp languages don't rigidly enforce a purely functional style like Haskell does, but if you want to program in a purely functional way, they certainly have the tools to do that. Actually, if you wanted to make your own parallel "Haskell" in Lisp, that would be possible since it excels at constructing metalanguages, and can make very quick foreign function calls to C/C++ libraries for multiprocessing or threading.</p></div>
	</htmltext>
<tokenext>In a proper functional language , there is no such thing as iteration .
There ca n't be .
The instant you say , " each time through the loop , increment the counter , and as soon as it hits this certain value stop , " you have stopped programming in a functional style.Recursion basically does the same thing , albeit through function calls and argument passing .
The difference is that it is " cleaner " because it 's incredibly simple , and because there are no state changes .
In Lisp languages you can just build your own looping constructs that use recursion under the hood , and get the best of both worlds .
Of course the Lisp languages do n't rigidly enforce a purely functional style like Haskell does , but if you want to program in a purely functional way , they certainly have the tools to do that .
Actually , if you wanted to make your own parallel " Haskell " in Lisp , that would be possible since it excels at constructing metalanguages , and can make very quick foreign function calls to C/C + + libraries for multiprocessing or threading .</tokentext>
<sentencetext>In a proper functional language, there is no such thing as iteration.
There can't be.
The instant you say, "each time through the loop, increment the counter, and as soon as it hits this certain value stop," you have stopped programming in a functional style.Recursion basically does the same thing, albeit through function calls and argument passing.
The difference is that it is "cleaner" because it's incredibly simple, and because there are no state changes.
In Lisp languages you can just build your own looping constructs that use recursion under the hood, and get the best of both worlds.
Of course the Lisp languages don't rigidly enforce a purely functional style like Haskell does, but if you want to program in a purely functional way, they certainly have the tools to do that.
Actually, if you wanted to make your own parallel "Haskell" in Lisp, that would be possible since it excels at constructing metalanguages, and can make very quick foreign function calls to C/C++ libraries for multiprocessing or threading.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219722</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219540</id>
	<title>Not to sound like an ass, but...</title>
	<author>XPeter</author>
	<datestamp>1259061060000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>What the hell have these guys been doing for the past four years? Only now they are implementing DoAndIfThenElse/EmptyDataDeclarations</p><p>Is this the Slackware of the programming world?</p></htmltext>
<tokenext>What the hell have these guys been doing for the past four years ?
Only now they are implementing DoAndIfThenElse/EmptyDataDeclarationsIs this the Slackware of the programming world ?</tokentext>
<sentencetext>What the hell have these guys been doing for the past four years?
Only now they are implementing DoAndIfThenElse/EmptyDataDeclarationsIs this the Slackware of the programming world?</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30223538</id>
	<title>Re:Is it just me ?</title>
	<author>syousef</author>
	<datestamp>1257194100000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><i>Facebook developed their real-time chat application in Erlang</i></p><p>Do you normally like to make your opponent's point for them? Facebook chat is horrible and buggy in my experience. Messages go missing. It freezes Firefox. It's just plain awful!</p></htmltext>
<tokenext>Facebook developed their real-time chat application in ErlangDo you normally like to make your opponent 's point for them ?
Facebook chat is horrible and buggy in my experience .
Messages go missing .
It freezes Firefox .
It 's just plain awful !</tokentext>
<sentencetext>Facebook developed their real-time chat application in ErlangDo you normally like to make your opponent's point for them?
Facebook chat is horrible and buggy in my experience.
Messages go missing.
It freezes Firefox.
It's just plain awful!</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219832</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30224062</id>
	<title>Re:Is it just me ?</title>
	<author>Hurricane78</author>
	<datestamp>1257158280000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>My argument is, that you can put this thoughts into general transformational formulas, and put them in the compiler.<nobr> <wbr></nobr>:)</p><p>I might be wrong, but at least I will try and find out / prove it.<nobr> <wbr></nobr>:)</p></htmltext>
<tokenext>My argument is , that you can put this thoughts into general transformational formulas , and put them in the compiler .
: ) I might be wrong , but at least I will try and find out / prove it .
: )</tokentext>
<sentencetext>My argument is, that you can put this thoughts into general transformational formulas, and put them in the compiler.
:)I might be wrong, but at least I will try and find out / prove it.
:)</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30222040</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220374</id>
	<title>Re:Concurrency?</title>
	<author>j1m+5n0w</author>
	<datestamp>1259064900000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>The announcement is perhaps a bit less interesting than the summary would have you believe... The most recent Haskell standard was Haskell 98, eleven years ago.  A new committee was formed to bring the standard up to date with current implementations.  Most of the changes listed have been in GHC and other implementations for some time now, and none of them appear to have anything to do with concurrency directly.  (Which isn't to say that interesting stuff hasn't been happening in the Haskell world in that area, it just doesn't directly affect the core language.)</htmltext>
<tokenext>The announcement is perhaps a bit less interesting than the summary would have you believe... The most recent Haskell standard was Haskell 98 , eleven years ago .
A new committee was formed to bring the standard up to date with current implementations .
Most of the changes listed have been in GHC and other implementations for some time now , and none of them appear to have anything to do with concurrency directly .
( Which is n't to say that interesting stuff has n't been happening in the Haskell world in that area , it just does n't directly affect the core language .
)</tokentext>
<sentencetext>The announcement is perhaps a bit less interesting than the summary would have you believe... The most recent Haskell standard was Haskell 98, eleven years ago.
A new committee was formed to bring the standard up to date with current implementations.
Most of the changes listed have been in GHC and other implementations for some time now, and none of them appear to have anything to do with concurrency directly.
(Which isn't to say that interesting stuff hasn't been happening in the Haskell world in that area, it just doesn't directly affect the core language.
)</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219580</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30223182</id>
	<title>Re:Concurrency?</title>
	<author>Anonymous</author>
	<datestamp>1259088900000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>I've a little experience with Haskell.  I've had to change my attitude from "If it compiles, it's bug-free" to "If it compiles and stops in finite time, it's bug-free".</p></htmltext>
<tokenext>I 've a little experience with Haskell .
I 've had to change my attitude from " If it compiles , it 's bug-free " to " If it compiles and stops in finite time , it 's bug-free " .</tokentext>
<sentencetext>I've a little experience with Haskell.
I've had to change my attitude from "If it compiles, it's bug-free" to "If it compiles and stops in finite time, it's bug-free".</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220100</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220074</id>
	<title>Re:Amazing day...</title>
	<author>Anonymous</author>
	<datestamp>1259063580000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>It's surprisingly popular on Project Euler.</htmltext>
<tokenext>It 's surprisingly popular on Project Euler .</tokentext>
<sentencetext>It's surprisingly popular on Project Euler.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219482</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220584</id>
	<title>Re:Is it just me ?</title>
	<author>j1m+5n0w</author>
	<datestamp>1259065980000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><blockquote><div><p>I wrote some code in that category but I never envisioned a functional programming language would suit the job. Am I the only one ?<nobr> <wbr></nobr>;-))</p></div></blockquote><p>Whether it works or not depends on what your task is and how you try to solve it.  There are several ways to do concurrency in Haskell, and they're each appropriate in different instances.  If you're just calling a lot of pure functions, then "par" and "seq" might be what you need.  If you need shared, mutable state, then STM might be a good approach.  If you want to do message passing or traditional locking, then using Chan and/or Mvar in the IO monad might be the right thing.

</p><p>I'd recommend looking at <a href="http://book.realworldhaskell.org/read/" title="realworldhaskell.org">Real World Haskell</a> [realworldhaskell.org] chapters 24 and 28.</p></div>
	</htmltext>
<tokenext>I wrote some code in that category but I never envisioned a functional programming language would suit the job .
Am I the only one ?
; - ) ) Whether it works or not depends on what your task is and how you try to solve it .
There are several ways to do concurrency in Haskell , and they 're each appropriate in different instances .
If you 're just calling a lot of pure functions , then " par " and " seq " might be what you need .
If you need shared , mutable state , then STM might be a good approach .
If you want to do message passing or traditional locking , then using Chan and/or Mvar in the IO monad might be the right thing .
I 'd recommend looking at Real World Haskell [ realworldhaskell.org ] chapters 24 and 28 .</tokentext>
<sentencetext>I wrote some code in that category but I never envisioned a functional programming language would suit the job.
Am I the only one ?
;-))Whether it works or not depends on what your task is and how you try to solve it.
There are several ways to do concurrency in Haskell, and they're each appropriate in different instances.
If you're just calling a lot of pure functions, then "par" and "seq" might be what you need.
If you need shared, mutable state, then STM might be a good approach.
If you want to do message passing or traditional locking, then using Chan and/or Mvar in the IO monad might be the right thing.
I'd recommend looking at Real World Haskell [realworldhaskell.org] chapters 24 and 28.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219458</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30223602</id>
	<title>Re:Is it just me ?</title>
	<author>Anonymous</author>
	<datestamp>1257195300000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Haskell's syntax is worse than C's. If someone could do the same for functional programming that Python does for the imperative (side-effect) languages<nobr> <wbr></nobr>...<br>And by the way one can write imperative code in Haskell</p></htmltext>
<tokenext>Haskell 's syntax is worse than C 's .
If someone could do the same for functional programming that Python does for the imperative ( side-effect ) languages ...And by the way one can write imperative code in Haskell</tokentext>
<sentencetext>Haskell's syntax is worse than C's.
If someone could do the same for functional programming that Python does for the imperative (side-effect) languages ...And by the way one can write imperative code in Haskell</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219722</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30222898</id>
	<title>Why isn't FP more popular?</title>
	<author>j1m+5n0w</author>
	<datestamp>1259085000000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><blockquote><div><p>Then why aren't the FP shops kicking as and taking names?</p></div></blockquote><p>There are several reasons.  As abigor stated, functional programming is not well understood by the majority of programmers.  If you suppose that there is one Haskell programmer for every 1000 Java programmers, then that one Haskell programmer has to be one thousand times more productive in order to get noticed by the larger programming community.  (I don't know if the distribution is that skewed, but I think you get the idea.)  There are small companies that have been very successful at using FP, but they're easy to miss if you don't look in the right places.

</p><p>Another reason is that the fastest functional languages are still slower than C in general.  I don't think the difference is as much as you say, Haskell and Ocaml both have very good code generators.  Do check out the "programming language shootout" results.  (Be sure to use -O2 with ghc, though, or you really will see a 10x difference.)  However, there are many programmers for whom if you give them a choice between one language and another, they will always choose the faster language regardless of other considerations.  A lot of supercomputing people still use Fortran, for example.

</p><p>A third reason is that software firms are very risk averse.  If you have a problem that you know a team of average Java, C++, or C# programmers can solve in N months, versus a smaller team of more expensive functional programmers who may or may not be able to solve the problem in much less time in an unknown language that no one else seems to be willing to bet the farm on, then a lot of firms will see FP as an unacceptable risk.

</p><p>Fourth, consider the sales pitch for Haskell:  "Hey, check out this cool new language!  It's a bit slower than C, and you can't change the value of any of the variables.  It was designed by committee.  Half of the people who use it got their PhD by hacking a type system extension onto ghc."  The primary benefits of Haskell are hard to describe to people who haven't used it, namely that programs tend to have fewer bugs (thanks to the strict type checker), and it often takes much less code to solve a given problem.  The drawbacks, however, are rather obvious up-front: how many programmers do you know who would welcome the idea of "everything is const"?  There aren't really any Haskell programs that you couldn't write in C, or Java, or C++, or C#, or Python or any of dozens of other languages.  The difference is, how much code are you going to write, and how much work is it going to take to make the program reliable?</p></div>
	</htmltext>
<tokenext>Then why are n't the FP shops kicking as and taking names ? There are several reasons .
As abigor stated , functional programming is not well understood by the majority of programmers .
If you suppose that there is one Haskell programmer for every 1000 Java programmers , then that one Haskell programmer has to be one thousand times more productive in order to get noticed by the larger programming community .
( I do n't know if the distribution is that skewed , but I think you get the idea .
) There are small companies that have been very successful at using FP , but they 're easy to miss if you do n't look in the right places .
Another reason is that the fastest functional languages are still slower than C in general .
I do n't think the difference is as much as you say , Haskell and Ocaml both have very good code generators .
Do check out the " programming language shootout " results .
( Be sure to use -O2 with ghc , though , or you really will see a 10x difference .
) However , there are many programmers for whom if you give them a choice between one language and another , they will always choose the faster language regardless of other considerations .
A lot of supercomputing people still use Fortran , for example .
A third reason is that software firms are very risk averse .
If you have a problem that you know a team of average Java , C + + , or C # programmers can solve in N months , versus a smaller team of more expensive functional programmers who may or may not be able to solve the problem in much less time in an unknown language that no one else seems to be willing to bet the farm on , then a lot of firms will see FP as an unacceptable risk .
Fourth , consider the sales pitch for Haskell : " Hey , check out this cool new language !
It 's a bit slower than C , and you ca n't change the value of any of the variables .
It was designed by committee .
Half of the people who use it got their PhD by hacking a type system extension onto ghc .
" The primary benefits of Haskell are hard to describe to people who have n't used it , namely that programs tend to have fewer bugs ( thanks to the strict type checker ) , and it often takes much less code to solve a given problem .
The drawbacks , however , are rather obvious up-front : how many programmers do you know who would welcome the idea of " everything is const " ?
There are n't really any Haskell programs that you could n't write in C , or Java , or C + + , or C # , or Python or any of dozens of other languages .
The difference is , how much code are you going to write , and how much work is it going to take to make the program reliable ?</tokentext>
<sentencetext>Then why aren't the FP shops kicking as and taking names?There are several reasons.
As abigor stated, functional programming is not well understood by the majority of programmers.
If you suppose that there is one Haskell programmer for every 1000 Java programmers, then that one Haskell programmer has to be one thousand times more productive in order to get noticed by the larger programming community.
(I don't know if the distribution is that skewed, but I think you get the idea.
)  There are small companies that have been very successful at using FP, but they're easy to miss if you don't look in the right places.
Another reason is that the fastest functional languages are still slower than C in general.
I don't think the difference is as much as you say, Haskell and Ocaml both have very good code generators.
Do check out the "programming language shootout" results.
(Be sure to use -O2 with ghc, though, or you really will see a 10x difference.
)  However, there are many programmers for whom if you give them a choice between one language and another, they will always choose the faster language regardless of other considerations.
A lot of supercomputing people still use Fortran, for example.
A third reason is that software firms are very risk averse.
If you have a problem that you know a team of average Java, C++, or C# programmers can solve in N months, versus a smaller team of more expensive functional programmers who may or may not be able to solve the problem in much less time in an unknown language that no one else seems to be willing to bet the farm on, then a lot of firms will see FP as an unacceptable risk.
Fourth, consider the sales pitch for Haskell:  "Hey, check out this cool new language!
It's a bit slower than C, and you can't change the value of any of the variables.
It was designed by committee.
Half of the people who use it got their PhD by hacking a type system extension onto ghc.
"  The primary benefits of Haskell are hard to describe to people who haven't used it, namely that programs tend to have fewer bugs (thanks to the strict type checker), and it often takes much less code to solve a given problem.
The drawbacks, however, are rather obvious up-front: how many programmers do you know who would welcome the idea of "everything is const"?
There aren't really any Haskell programs that you couldn't write in C, or Java, or C++, or C#, or Python or any of dozens of other languages.
The difference is, how much code are you going to write, and how much work is it going to take to make the program reliable?
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30221686</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220462</id>
	<title>Re:Is it just me ?</title>
	<author>Anonymous</author>
	<datestamp>1259065380000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Renaissance implies a certain significance or magnitude. There is no need to call it enormous too.</p></htmltext>
<tokenext>Renaissance implies a certain significance or magnitude .
There is no need to call it enormous too .</tokentext>
<sentencetext>Renaissance implies a certain significance or magnitude.
There is no need to call it enormous too.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219722</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220780</id>
	<title>Re:But I'm lazy...</title>
	<author>Hurricane78</author>
	<datestamp>1259067000000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>But learning Haskell is only in a small part about writing Haskell. It&rsquo;s mainly about getting to the next level in programming skill. And becoming much better in <em>every</em> language.</p><p>Besides: Want to earn some big money for doing actual &ldquo;mission-critical&rdquo; software, that lives depend on, and that really means something? There&rsquo;s no way to do serious business like that without Haskell, and not go crazy. ^^</p><p>So there you go. If you want to continue doing basically a front-end to a database on color mixing machines, or a sales system, to earn enough to live, then go ahead, continue doing C++/Java/Delphi.<nobr> <wbr></nobr>:)</p></htmltext>
<tokenext>But learning Haskell is only in a small part about writing Haskell .
It    s mainly about getting to the next level in programming skill .
And becoming much better in every language.Besides : Want to earn some big money for doing actual    mission-critical    software , that lives depend on , and that really means something ?
There    s no way to do serious business like that without Haskell , and not go crazy .
^ ^ So there you go .
If you want to continue doing basically a front-end to a database on color mixing machines , or a sales system , to earn enough to live , then go ahead , continue doing C + + /Java/Delphi .
: )</tokentext>
<sentencetext>But learning Haskell is only in a small part about writing Haskell.
It’s mainly about getting to the next level in programming skill.
And becoming much better in every language.Besides: Want to earn some big money for doing actual “mission-critical” software, that lives depend on, and that really means something?
There’s no way to do serious business like that without Haskell, and not go crazy.
^^So there you go.
If you want to continue doing basically a front-end to a database on color mixing machines, or a sales system, to earn enough to live, then go ahead, continue doing C++/Java/Delphi.
:)</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219560</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219938</id>
	<title>Re:Not to sound like an ass, but...</title>
	<author>Anonymous</author>
	<datestamp>1259063040000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>DoAndIfThenElse isn't a new feature; it just addresses some unintuitive syntax when using multiline "if-then-else" forms in a "do" block.</p><p>EmptyDataDeclarations allows for data types without a constructor... but to be perfectly honest I haven't quite figured out what practical benefit they have<nobr> <wbr></nobr>:). I'm sure there is a reason, but I don't think it's as trivial or obvious as you make out.</p></htmltext>
<tokenext>DoAndIfThenElse is n't a new feature ; it just addresses some unintuitive syntax when using multiline " if-then-else " forms in a " do " block.EmptyDataDeclarations allows for data types without a constructor... but to be perfectly honest I have n't quite figured out what practical benefit they have : ) .
I 'm sure there is a reason , but I do n't think it 's as trivial or obvious as you make out .</tokentext>
<sentencetext>DoAndIfThenElse isn't a new feature; it just addresses some unintuitive syntax when using multiline "if-then-else" forms in a "do" block.EmptyDataDeclarations allows for data types without a constructor... but to be perfectly honest I haven't quite figured out what practical benefit they have :).
I'm sure there is a reason, but I don't think it's as trivial or obvious as you make out.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219540</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219740</id>
	<title>Re:Is it just me ?</title>
	<author>lorenlal</author>
	<datestamp>1259061960000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I guess not, since that's what these folks put together.</p><p>Seriously though, it's my experience that there aren't too many people out there writing much with concurrency and SMP in mind to start with.  I'm not sure how they did it, but if they can bring parallelism to another method of programming, then fine by me.  The more people get used to utilizing the multiple cores available to them, the better IMHO.</p></htmltext>
<tokenext>I guess not , since that 's what these folks put together.Seriously though , it 's my experience that there are n't too many people out there writing much with concurrency and SMP in mind to start with .
I 'm not sure how they did it , but if they can bring parallelism to another method of programming , then fine by me .
The more people get used to utilizing the multiple cores available to them , the better IMHO .</tokentext>
<sentencetext>I guess not, since that's what these folks put together.Seriously though, it's my experience that there aren't too many people out there writing much with concurrency and SMP in mind to start with.
I'm not sure how they did it, but if they can bring parallelism to another method of programming, then fine by me.
The more people get used to utilizing the multiple cores available to them, the better IMHO.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219458</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219586</id>
	<title>Oh, be still my heart....</title>
	<author>gestalt\_n\_pepper</author>
	<datestamp>1259061300000</datestamp>
	<modclass>Funny</modclass>
	<modscore>2</modscore>
	<htmltext><p>Haskell! Haskell! Every geek's favorite mental masturbation toy!</p></htmltext>
<tokenext>Haskell !
Haskell ! Every geek 's favorite mental masturbation toy !</tokentext>
<sentencetext>Haskell!
Haskell! Every geek's favorite mental masturbation toy!</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219844</id>
	<title>meh</title>
	<author>AlgorithMan</author>
	<datestamp>1259062500000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>Haskell can't compete with my implementation of the pure lambda calculus!<br>
screw all that syntactic sugar, lambda expressions ftw!</htmltext>
<tokenext>Haskell ca n't compete with my implementation of the pure lambda calculus !
screw all that syntactic sugar , lambda expressions ftw !</tokentext>
<sentencetext>Haskell can't compete with my implementation of the pure lambda calculus!
screw all that syntactic sugar, lambda expressions ftw!</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220672</id>
	<title>Re:Is it just me ?</title>
	<author>Anonymous</author>
	<datestamp>1259066400000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>3</modscore>
	<htmltext><p>The idea is that you can split up the program in parallel tasks in a fully automated way. If you as a programmer even have to think about parallelizing, I&rsquo;m sorry, but then your compiler is &ldquo;doin&rsquo; it wrong&rdquo; and your languages is from the stone age. ^^<br>An a bonus, when you can completely rely on a function with the same input producing the same output, you can also throw caching in there algorithmically (where required, on-demand, whatever you wish)<br>But bla... that is all just the stuff on the surface. Like explaining the pointlessness of &ldquo;metaprogramming&rdquo; when there stops being a difference between data and code.</p><p>I find the most amazing thing about Haskell as it is today, is that things that need the addition of new constructs to the language and a big change in the compiler, are just your normal library in Haskell. It can look like a whole new language. But it&rsquo;s just a library. And that is amazing!<br>Then, when you get to the GHC <em>extensions</em>, things that are as much on the forefront of Informatics science as the LHC on physics, with everybody else copying it years later... Sorry, but if you like elegance in programming,<nobr> <wbr></nobr>...I just have no words for it...</p><p>The thing is, that it&rsquo;s crazy hard to learn. Which is not a fault in language design. Because it&rsquo;s very elegant. It&rsquo;s simply the fact that it <em>is</em> so far ahead of anything in your everyday language. You won&rsquo;t expect to sit in a spaceship and drive it like your car too, would you? Or program the LHC like a VCR.</p><p>Yes, I am a fan. Even if I sometimes hate it for being so damn smart compared to me the normal programmer. But I became so much a better programmer in all other languages, it&rsquo;s crazy.</p><p>It&rsquo;s simply a completely different class of skill. And that is why one should learn Haskell. Fuck the &ldquo;Oh, we&rsquo;re now only coding in Haskell&rdquo; attitude. When you really <em>understand</em> the ideas behind it, every language becomes Haskell. And you can write practically bug-free programs of...</p><p>Aaah, what am I saying. &lt;John Cleese&gt;Oh it&rsquo;s driving me mad...  MAD!&lt;/John Cleese&gt; <em>*slams cleaver into the table*</em><br><em>*head developer comes in*</em><br>Head developer: Easy, Mungo, easy... Mungo... <em>*clutches his head in agony*</em> the war wound!... the wound... the wouuund...<br>Manager: This is the end! The end! Aaargh!! <em>*stabs himself with a steel lambda sculpture*</em></p></htmltext>
<tokenext>The idea is that you can split up the program in parallel tasks in a fully automated way .
If you as a programmer even have to think about parallelizing , I    m sorry , but then your compiler is    doin    it wrong    and your languages is from the stone age .
^ ^ An a bonus , when you can completely rely on a function with the same input producing the same output , you can also throw caching in there algorithmically ( where required , on-demand , whatever you wish ) But bla... that is all just the stuff on the surface .
Like explaining the pointlessness of    metaprogramming    when there stops being a difference between data and code.I find the most amazing thing about Haskell as it is today , is that things that need the addition of new constructs to the language and a big change in the compiler , are just your normal library in Haskell .
It can look like a whole new language .
But it    s just a library .
And that is amazing ! Then , when you get to the GHC extensions , things that are as much on the forefront of Informatics science as the LHC on physics , with everybody else copying it years later... Sorry , but if you like elegance in programming , ...I just have no words for it...The thing is , that it    s crazy hard to learn .
Which is not a fault in language design .
Because it    s very elegant .
It    s simply the fact that it is so far ahead of anything in your everyday language .
You won    t expect to sit in a spaceship and drive it like your car too , would you ?
Or program the LHC like a VCR.Yes , I am a fan .
Even if I sometimes hate it for being so damn smart compared to me the normal programmer .
But I became so much a better programmer in all other languages , it    s crazy.It    s simply a completely different class of skill .
And that is why one should learn Haskell .
Fuck the    Oh , we    re now only coding in Haskell    attitude .
When you really understand the ideas behind it , every language becomes Haskell .
And you can write practically bug-free programs of...Aaah , what am I saying .
Oh it    s driving me mad... MAD ! * slams cleaver into the table * * head developer comes in * Head developer : Easy , Mungo , easy... Mungo... * clutches his head in agony * the war wound ! .. .
the wound... the wouuund...Manager : This is the end !
The end !
Aaargh ! ! * stabs himself with a steel lambda sculpture *</tokentext>
<sentencetext>The idea is that you can split up the program in parallel tasks in a fully automated way.
If you as a programmer even have to think about parallelizing, I’m sorry, but then your compiler is “doin’ it wrong” and your languages is from the stone age.
^^An a bonus, when you can completely rely on a function with the same input producing the same output, you can also throw caching in there algorithmically (where required, on-demand, whatever you wish)But bla... that is all just the stuff on the surface.
Like explaining the pointlessness of “metaprogramming” when there stops being a difference between data and code.I find the most amazing thing about Haskell as it is today, is that things that need the addition of new constructs to the language and a big change in the compiler, are just your normal library in Haskell.
It can look like a whole new language.
But it’s just a library.
And that is amazing!Then, when you get to the GHC extensions, things that are as much on the forefront of Informatics science as the LHC on physics, with everybody else copying it years later... Sorry, but if you like elegance in programming, ...I just have no words for it...The thing is, that it’s crazy hard to learn.
Which is not a fault in language design.
Because it’s very elegant.
It’s simply the fact that it is so far ahead of anything in your everyday language.
You won’t expect to sit in a spaceship and drive it like your car too, would you?
Or program the LHC like a VCR.Yes, I am a fan.
Even if I sometimes hate it for being so damn smart compared to me the normal programmer.
But I became so much a better programmer in all other languages, it’s crazy.It’s simply a completely different class of skill.
And that is why one should learn Haskell.
Fuck the “Oh, we’re now only coding in Haskell” attitude.
When you really understand the ideas behind it, every language becomes Haskell.
And you can write practically bug-free programs of...Aaah, what am I saying.
Oh it’s driving me mad...  MAD! *slams cleaver into the table**head developer comes in*Head developer: Easy, Mungo, easy... Mungo... *clutches his head in agony* the war wound!...
the wound... the wouuund...Manager: This is the end!
The end!
Aaargh!! *stabs himself with a steel lambda sculpture*</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219458</parent>
</comment>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_24_2120246_15</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220462
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219722
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219458
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_24_2120246_22</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220584
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219458
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_24_2120246_21</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30221068
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219722
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219458
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_24_2120246_12</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30223006
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219938
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219540
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_24_2120246_4</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30223602
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219722
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219458
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_24_2120246_30</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220566
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219482
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_24_2120246_13</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220074
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219482
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_24_2120246_27</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30224900
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219722
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219458
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_24_2120246_20</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220700
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219482
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_24_2120246_9</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30222080
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219586
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_24_2120246_10</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30222212
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219722
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219458
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_24_2120246_19</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30225324
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30221244
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220332
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220086
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219832
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219458
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_24_2120246_26</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30221082
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219832
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219458
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_24_2120246_25</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30223538
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219832
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219458
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_24_2120246_16</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30222312
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220100
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219580
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_24_2120246_8</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220176
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219580
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_24_2120246_31</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30224916
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220354
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219482
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_24_2120246_3</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30222008
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220672
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219458
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_24_2120246_17</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30231598
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30224116
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_24_2120246_24</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30224062
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30222040
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220672
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219458
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_24_2120246_14</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220432
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220246
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220086
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219832
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219458
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_24_2120246_0</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30223182
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220100
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219580
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_24_2120246_2</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220374
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219580
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_24_2120246_1</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220256
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219458
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_24_2120246_29</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30222746
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220100
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219580
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_24_2120246_11</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30229664
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30224116
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_24_2120246_7</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30224994
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30221244
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220332
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220086
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219832
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219458
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_24_2120246_28</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219740
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219458
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_24_2120246_32</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30222898
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30221686
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219722
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219458
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_24_2120246_18</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30221120
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219722
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219458
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_24_2120246_23</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220780
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219560
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_24_2120246_6</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30222742
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220672
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219458
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_09_11_24_2120246_5</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30223642
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219586
</commentlist>
</thread>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_24_2120246.1</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219540
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219938
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30223006
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_24_2120246.4</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30224116
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30231598
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30229664
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_24_2120246.2</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219482
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220074
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220700
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220566
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220354
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30224916
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_24_2120246.5</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219580
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220176
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220100
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30222312
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30222746
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30223182
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220374
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_24_2120246.3</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219560
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220780
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_24_2120246.6</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219458
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220672
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30222040
---http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30224062
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30222008
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30222742
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220256
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219722
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30224900
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30221068
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220462
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30223602
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30221120
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30221686
---http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30222898
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30222212
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219832
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220086
---http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220246
----http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220432
---http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220332
----http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30221244
-----http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30224994
-----http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30225324
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30223538
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30221082
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30220584
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219740
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_24_2120246.0</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219586
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30222080
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30223642
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation09_11_24_2120246.7</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment09_11_24_2120246.30219556
</commentlist>
</conversation>
