<article>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#article10_02_07_0059233</id>
	<title>An Interview With F# Creator Don Syme</title>
	<author>kdawson</author>
	<datestamp>1265571060000</datestamp>
	<htmltext>OCatenac passes along an <a href="http://www.simple-talk.com/opinion/geek-of-the-week/don-syme-geek-of-the-week/">interview with Don Syme, chief designer of F#</a>, which is Microsoft Research's offering for functional programming on the .Net platform. Like <a href="//tech.slashdot.org/story/09/08/18/1725217/Scala-a-Statically-Typed-Functional-O-O-Language">Scala</a>, which we discussed last fall, F# aims at being an optimal blend of functional and object-oriented languages. <i>"[Q] What is the best program you've seen written in F#? [A] I've mentioned the samples from F# for Scientists, which are very compelling... For commercial impact then the uses of F# in the finance industry have been very convincing, but probably nothing beats the uses of F# to implement statistical machine learning algorithms as part of the Bing advertisement delivery machinery. ... We've recently really focused on ensuring that programming in F# is simple and intuitive. For example, I greatly enjoyed working with a high-school student who learned F#. After a few days she was accurately modifying a solar system simulator, despite the fact she'd never programmed before. You really learn a lot by watching a student at that stage."</i></htmltext>
<tokenext>OCatenac passes along an interview with Don Syme , chief designer of F # , which is Microsoft Research 's offering for functional programming on the .Net platform .
Like Scala , which we discussed last fall , F # aims at being an optimal blend of functional and object-oriented languages .
" [ Q ] What is the best program you 've seen written in F # ?
[ A ] I 've mentioned the samples from F # for Scientists , which are very compelling... For commercial impact then the uses of F # in the finance industry have been very convincing , but probably nothing beats the uses of F # to implement statistical machine learning algorithms as part of the Bing advertisement delivery machinery .
... We 've recently really focused on ensuring that programming in F # is simple and intuitive .
For example , I greatly enjoyed working with a high-school student who learned F # .
After a few days she was accurately modifying a solar system simulator , despite the fact she 'd never programmed before .
You really learn a lot by watching a student at that stage .
"</tokentext>
<sentencetext>OCatenac passes along an interview with Don Syme, chief designer of F#, which is Microsoft Research's offering for functional programming on the .Net platform.
Like Scala, which we discussed last fall, F# aims at being an optimal blend of functional and object-oriented languages.
"[Q] What is the best program you've seen written in F#?
[A] I've mentioned the samples from F# for Scientists, which are very compelling... For commercial impact then the uses of F# in the finance industry have been very convincing, but probably nothing beats the uses of F# to implement statistical machine learning algorithms as part of the Bing advertisement delivery machinery.
... We've recently really focused on ensuring that programming in F# is simple and intuitive.
For example, I greatly enjoyed working with a high-school student who learned F#.
After a few days she was accurately modifying a solar system simulator, despite the fact she'd never programmed before.
You really learn a lot by watching a student at that stage.
"</sentencetext>
</article>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051250</id>
	<title>Not even going to RTFA</title>
	<author>Agamous Child</author>
	<datestamp>1265539500000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>1</modscore>
	<htmltext>Totally marketing garbage. Man is probably a great guy, with a lousy job. But F#, really? even<nobr> <wbr></nobr>.NET is ripping off Java. Microsoft talks about building "ecosystems" but the way they do it, everything in the ecosystem has to have a M$ logo on it. Why can't they just inter-operate and integrate with outside software?</htmltext>
<tokenext>Totally marketing garbage .
Man is probably a great guy , with a lousy job .
But F # , really ?
even .NET is ripping off Java .
Microsoft talks about building " ecosystems " but the way they do it , everything in the ecosystem has to have a M $ logo on it .
Why ca n't they just inter-operate and integrate with outside software ?</tokentext>
<sentencetext>Totally marketing garbage.
Man is probably a great guy, with a lousy job.
But F#, really?
even .NET is ripping off Java.
Microsoft talks about building "ecosystems" but the way they do it, everything in the ecosystem has to have a M$ logo on it.
Why can't they just inter-operate and integrate with outside software?</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31052760</id>
	<title>Re:Looks interesting as replacement for Python</title>
	<author>Anonymous</author>
	<datestamp>1265562600000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Just a quick insight into why Python's indexing makes utter sense to me, and why what you're suggesting would drive me nuts (I know this because the codebase I have to maintain has classes that work the way you describe, and I wish it would do it the way Python does it).</p><p>That's not to say that your preference is without merit, just to show that there are two equally valid points of view.</p><p>Python's slicing syntax means that mylist[n:m] will have (m-n) elements in it, and not (m-n)+1. This has several nice side-effects; for example mylist[n:n] will be an empty list and will never be iterated over, and mylist[0:N] is the same as mylist[0:1] + mylist[1:2] + mylist[2:3] +<nobr> <wbr></nobr>... mylist[N-1:N].</p></htmltext>
<tokenext>Just a quick insight into why Python 's indexing makes utter sense to me , and why what you 're suggesting would drive me nuts ( I know this because the codebase I have to maintain has classes that work the way you describe , and I wish it would do it the way Python does it ) .That 's not to say that your preference is without merit , just to show that there are two equally valid points of view.Python 's slicing syntax means that mylist [ n : m ] will have ( m-n ) elements in it , and not ( m-n ) + 1 .
This has several nice side-effects ; for example mylist [ n : n ] will be an empty list and will never be iterated over , and mylist [ 0 : N ] is the same as mylist [ 0 : 1 ] + mylist [ 1 : 2 ] + mylist [ 2 : 3 ] + ... mylist [ N-1 : N ] .</tokentext>
<sentencetext>Just a quick insight into why Python's indexing makes utter sense to me, and why what you're suggesting would drive me nuts (I know this because the codebase I have to maintain has classes that work the way you describe, and I wish it would do it the way Python does it).That's not to say that your preference is without merit, just to show that there are two equally valid points of view.Python's slicing syntax means that mylist[n:m] will have (m-n) elements in it, and not (m-n)+1.
This has several nice side-effects; for example mylist[n:n] will be an empty list and will never be iterated over, and mylist[0:N] is the same as mylist[0:1] + mylist[1:2] + mylist[2:3] + ... mylist[N-1:N].</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051356</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31052074</id>
	<title>Evolution</title>
	<author>Skeptical1</author>
	<datestamp>1265554260000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>Looks like the languages are breeding.   Look at the 'DNA' combining.  Not Pretty.  Lots of extinctions.  If you can't stand the mess get out of the pool.</htmltext>
<tokenext>Looks like the languages are breeding .
Look at the 'DNA ' combining .
Not Pretty .
Lots of extinctions .
If you ca n't stand the mess get out of the pool .</tokentext>
<sentencetext>Looks like the languages are breeding.
Look at the 'DNA' combining.
Not Pretty.
Lots of extinctions.
If you can't stand the mess get out of the pool.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051780</id>
	<title>Re:Looks interesting as replacement for Python</title>
	<author>selven</author>
	<datestamp>1265548680000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>4</modscore>
	<htmltext><tt>I agree that Python has some strange things about it, but look at some sample f# syntax from Wikipedia:<br><br>let rec factorial n =<br>&nbsp; &nbsp; match n with<br>&nbsp; &nbsp; | 0I -&gt; 1I<br>&nbsp; &nbsp; | \_ -&gt; n * factorial (n - 1I)<br><br>What do those funny characters mean? What's the I after the numbers? Compare to the python one liner:<br><br>def factorial(n): return 1 if n == 0 else n * factorial (n-1)<br><br>That makes sense even to someone with absolutely zero experience in the language.</tt></htmltext>
<tokenext>I agree that Python has some strange things about it , but look at some sample f # syntax from Wikipedia : let rec factorial n =     match n with     | 0I - &gt; 1I     | \ _ - &gt; n * factorial ( n - 1I ) What do those funny characters mean ?
What 's the I after the numbers ?
Compare to the python one liner : def factorial ( n ) : return 1 if n = = 0 else n * factorial ( n-1 ) That makes sense even to someone with absolutely zero experience in the language .</tokentext>
<sentencetext>I agree that Python has some strange things about it, but look at some sample f# syntax from Wikipedia:let rec factorial n =    match n with    | 0I -&gt; 1I    | \_ -&gt; n * factorial (n - 1I)What do those funny characters mean?
What's the I after the numbers?
Compare to the python one liner:def factorial(n): return 1 if n == 0 else n * factorial (n-1)That makes sense even to someone with absolutely zero experience in the language.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051356</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051514</id>
	<title>Re:.NET Framework</title>
	<author>Paradigma11</author>
	<datestamp>1265544060000</datestamp>
	<modclass>Informativ</modclass>
	<modscore>4</modscore>
	<htmltext><tt>Dr Eric Meijer from microsoft research has given a pretty nice 13 part lecture on functional programming in haskell based on graham huttons book:<br>http://channel9.msdn.com/shows/Going+Deep/Lecture-Series-Erik-Meijer-Functional-Programming-Fundamentals-Chapter-1/<br>there are also a ton of other videos about f# on channel9 like:<br>http://channel9.msdn.com/posts/martinesmann/Don-Syme-FSharp-and-functional-programming-in-NET/<br>http://channel9.msdn.com/shows/Going+Deep/C9-Lectures-Dr-Don-Syme-Introduction-to-F-1-of-3/<br>or others specifically on asynchronicity and parallelism in f#....</tt></htmltext>
<tokenext>Dr Eric Meijer from microsoft research has given a pretty nice 13 part lecture on functional programming in haskell based on graham huttons book : http : //channel9.msdn.com/shows/Going + Deep/Lecture-Series-Erik-Meijer-Functional-Programming-Fundamentals-Chapter-1/there are also a ton of other videos about f # on channel9 like : http : //channel9.msdn.com/posts/martinesmann/Don-Syme-FSharp-and-functional-programming-in-NET/http : //channel9.msdn.com/shows/Going + Deep/C9-Lectures-Dr-Don-Syme-Introduction-to-F-1-of-3/or others specifically on asynchronicity and parallelism in f # ... .</tokentext>
<sentencetext>Dr Eric Meijer from microsoft research has given a pretty nice 13 part lecture on functional programming in haskell based on graham huttons book:http://channel9.msdn.com/shows/Going+Deep/Lecture-Series-Erik-Meijer-Functional-Programming-Fundamentals-Chapter-1/there are also a ton of other videos about f# on channel9 like:http://channel9.msdn.com/posts/martinesmann/Don-Syme-FSharp-and-functional-programming-in-NET/http://channel9.msdn.com/shows/Going+Deep/C9-Lectures-Dr-Don-Syme-Introduction-to-F-1-of-3/or others specifically on asynchronicity and parallelism in f#....</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051062</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051076</id>
	<title>The optimal blend...</title>
	<author>mandelbr0t</author>
	<datestamp>1265535120000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>2</modscore>
	<htmltext>...of object-oriented and functional programming languages would be one without any functional perspective. I've learned both, I've managed both, and OO didn't drive me insane. Functional-based programming languages are syntactically inferior to OO ones, just as natural languages have features that make some more primitive than others.</htmltext>
<tokenext>...of object-oriented and functional programming languages would be one without any functional perspective .
I 've learned both , I 've managed both , and OO did n't drive me insane .
Functional-based programming languages are syntactically inferior to OO ones , just as natural languages have features that make some more primitive than others .</tokentext>
<sentencetext>...of object-oriented and functional programming languages would be one without any functional perspective.
I've learned both, I've managed both, and OO didn't drive me insane.
Functional-based programming languages are syntactically inferior to OO ones, just as natural languages have features that make some more primitive than others.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31053308</id>
	<title>Re:Looks interesting as replacement for Python</title>
	<author>GreyWolf3000</author>
	<datestamp>1265567880000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><tt>I second the ruby suggestion.<br><br>bash# irb<br><br>&gt;&gt; (2..5).each { |number| puts number }<br>2<br>3<br>4<br>5<br>&gt;&gt;<br><br>&gt;&gt; (2..5).to\_a<br>[ 2, 3, 4, 5 ]<br>&gt;&gt;<br><br>&gt;&gt; (2...5).to\_a<br>[ 2, 3, 4 ]<br>&gt;&gt;<br><br>&gt;&gt; [ "apple", "orange", "banana", "peach" ].each do |fruit|<br>&nbsp; puts "Yummy, #{fruit.pluralize}!"<br>end<br>Yummy, apples!<br>Yummy, oranges!<br>Yummy, bananas!<br>Yummy, peaches!<br>&gt;&gt;<br></tt></htmltext>
<tokenext>I second the ruby suggestion.bash # irb &gt; &gt; ( 2..5 ) .each { | number | puts number } 2345 &gt; &gt; &gt; &gt; ( 2..5 ) .to \ _a [ 2 , 3 , 4 , 5 ] &gt; &gt; &gt; &gt; ( 2...5 ) .to \ _a [ 2 , 3 , 4 ] &gt; &gt; &gt; &gt; [ " apple " , " orange " , " banana " , " peach " ] .each do | fruit |   puts " Yummy , # { fruit.pluralize } !
" endYummy , apples ! Yummy , oranges ! Yummy , bananas ! Yummy , peaches ! &gt; &gt;</tokentext>
<sentencetext>I second the ruby suggestion.bash# irb&gt;&gt; (2..5).each { |number| puts number }2345&gt;&gt;&gt;&gt; (2..5).to\_a[ 2, 3, 4, 5 ]&gt;&gt;&gt;&gt; (2...5).to\_a[ 2, 3, 4 ]&gt;&gt;&gt;&gt; [ "apple", "orange", "banana", "peach" ].each do |fruit|  puts "Yummy, #{fruit.pluralize}!
"endYummy, apples!Yummy, oranges!Yummy, bananas!Yummy, peaches!&gt;&gt;</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051356</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051020</id>
	<title>Re:Anyone else think is was a .NET Fortran?</title>
	<author>rahuja</author>
	<datestamp>1265534040000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>Yeah, that was my initial reaction too before reading the summary.</htmltext>
<tokenext>Yeah , that was my initial reaction too before reading the summary .</tokentext>
<sentencetext>Yeah, that was my initial reaction too before reading the summary.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050952</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31056696</id>
	<title>Re:Object oriented and functional cannot be combin</title>
	<author>shutdown -p now</author>
	<datestamp>1265552280000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>It is impossible to combine a object oriented language with a functional language.</p></div><p>You have to go tell OCaml authors that...</p><p><div class="quote"><p>Functional languages are about values.</p></div><p>Not at all. I'm not sure what you mean by "values" here (I'll touch on that below), but the strict definition of a functional language is "a language that has functions as first-class values". That's all there is to it.</p><p><div class="quote"><p>Values are closed. Values are the opposite of objects.</p></div><p>I think you need to provide your definition of "object" and "value" at this point. Are you referring to the fact that objects have inherent identity, while values do not? What about immutable objects, that are used solely for encapsulation and virtual dispatch (a la OCaml)? How are they any different from ADTs?</p><p>Or do you refer to immutability? It's not a hallmark of a functional language, either. For example, both Scheme and Standard ML have mutable values, but they're definitely functional. On the other hand, XQuery is pure - output is a strict function of input, no mutable state at all - but it doesn't have function types nor values, and so it's non-functional.</p><p><div class="quote"><p>Everybody who claims that functional and object oriented can be joined either does not understand what these words mean or have an alternative interprettation of what of either one of the two terms.</p></div><p>"Alternative" relative to what? Yet again, you really need to provide <em>your</em> definitions for this to be comprehensible.</p></div>
	</htmltext>
<tokenext>It is impossible to combine a object oriented language with a functional language.You have to go tell OCaml authors that...Functional languages are about values.Not at all .
I 'm not sure what you mean by " values " here ( I 'll touch on that below ) , but the strict definition of a functional language is " a language that has functions as first-class values " .
That 's all there is to it.Values are closed .
Values are the opposite of objects.I think you need to provide your definition of " object " and " value " at this point .
Are you referring to the fact that objects have inherent identity , while values do not ?
What about immutable objects , that are used solely for encapsulation and virtual dispatch ( a la OCaml ) ?
How are they any different from ADTs ? Or do you refer to immutability ?
It 's not a hallmark of a functional language , either .
For example , both Scheme and Standard ML have mutable values , but they 're definitely functional .
On the other hand , XQuery is pure - output is a strict function of input , no mutable state at all - but it does n't have function types nor values , and so it 's non-functional.Everybody who claims that functional and object oriented can be joined either does not understand what these words mean or have an alternative interprettation of what of either one of the two terms .
" Alternative " relative to what ?
Yet again , you really need to provide your definitions for this to be comprehensible .</tokentext>
<sentencetext>It is impossible to combine a object oriented language with a functional language.You have to go tell OCaml authors that...Functional languages are about values.Not at all.
I'm not sure what you mean by "values" here (I'll touch on that below), but the strict definition of a functional language is "a language that has functions as first-class values".
That's all there is to it.Values are closed.
Values are the opposite of objects.I think you need to provide your definition of "object" and "value" at this point.
Are you referring to the fact that objects have inherent identity, while values do not?
What about immutable objects, that are used solely for encapsulation and virtual dispatch (a la OCaml)?
How are they any different from ADTs?Or do you refer to immutability?
It's not a hallmark of a functional language, either.
For example, both Scheme and Standard ML have mutable values, but they're definitely functional.
On the other hand, XQuery is pure - output is a strict function of input, no mutable state at all - but it doesn't have function types nor values, and so it's non-functional.Everybody who claims that functional and object oriented can be joined either does not understand what these words mean or have an alternative interprettation of what of either one of the two terms.
"Alternative" relative to what?
Yet again, you really need to provide your definitions for this to be comprehensible.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31055248</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31057034</id>
	<title>Re:Looks interesting as replacement for Python</title>
	<author>lahvak</author>
	<datestamp>1265555460000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I know absolutely nothing about F#.  Let's see what I can make of it:</p><p>My guess is that the I after the number means integer.  We are defining a function named factorial, which takes one argument, n, and if it is exactly 0, it returns 1, and if it is anything else, it recurses.  I am not sure what the "rec" means, perhaps it tells the compiler that it is a recursive function?  It is also unclear to me what is going to happen if you feed it a non-integer, or a negative integer.</p><p>As far as the python one-liner, I know python pretty well, but I have to think a bit to actually decipher what is it going to do.  Does it mean</p><p><tt>(return 1) if n == 0<nobr> <wbr></nobr>...</tt>  or <tt>return (1 if<nobr> <wbr></nobr>...)</tt>?</p></htmltext>
<tokenext>I know absolutely nothing about F # .
Let 's see what I can make of it : My guess is that the I after the number means integer .
We are defining a function named factorial , which takes one argument , n , and if it is exactly 0 , it returns 1 , and if it is anything else , it recurses .
I am not sure what the " rec " means , perhaps it tells the compiler that it is a recursive function ?
It is also unclear to me what is going to happen if you feed it a non-integer , or a negative integer.As far as the python one-liner , I know python pretty well , but I have to think a bit to actually decipher what is it going to do .
Does it mean ( return 1 ) if n = = 0 ... or return ( 1 if ... ) ?</tokentext>
<sentencetext>I know absolutely nothing about F#.
Let's see what I can make of it:My guess is that the I after the number means integer.
We are defining a function named factorial, which takes one argument, n, and if it is exactly 0, it returns 1, and if it is anything else, it recurses.
I am not sure what the "rec" means, perhaps it tells the compiler that it is a recursive function?
It is also unclear to me what is going to happen if you feed it a non-integer, or a negative integer.As far as the python one-liner, I know python pretty well, but I have to think a bit to actually decipher what is it going to do.
Does it mean(return 1) if n == 0 ...  or return (1 if ...)?</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051780</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051602</id>
	<title>Re:.NET Framework</title>
	<author>JamesP</author>
	<datestamp>1265545620000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>I really want to take a moment to say that the<nobr> <wbr></nobr>.NET Framework really is excellent. The ability to mix and match different paradigms and languages in a clean an concise manner which is a joy to program in.</p><p>Yeah I know patents bla bla mono bla bla Novell bla bla Miguel bla bla.</p></div><p>I agree wholeheartedly. Even though I haven't played with IronPython yet, just C# but for me that's enough (even though it has its gotchas)</p></div>
	</htmltext>
<tokenext>I really want to take a moment to say that the .NET Framework really is excellent .
The ability to mix and match different paradigms and languages in a clean an concise manner which is a joy to program in.Yeah I know patents bla bla mono bla bla Novell bla bla Miguel bla bla.I agree wholeheartedly .
Even though I have n't played with IronPython yet , just C # but for me that 's enough ( even though it has its gotchas )</tokentext>
<sentencetext>I really want to take a moment to say that the .NET Framework really is excellent.
The ability to mix and match different paradigms and languages in a clean an concise manner which is a joy to program in.Yeah I know patents bla bla mono bla bla Novell bla bla Miguel bla bla.I agree wholeheartedly.
Even though I haven't played with IronPython yet, just C# but for me that's enough (even though it has its gotchas)
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051062</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050962</id>
	<title>never programmed before???</title>
	<author>madddddddddd</author>
	<datestamp>1265575680000</datestamp>
	<modclass>Troll</modclass>
	<modscore>0</modscore>
	<htmltext><p>the solar system is a program of physics.   a child understanding the program enough to alter a simulation of it makes the claim of the child having no programming experience quite questionable.</p><p>go tell someone else, marketing droid.  F# stinks.</p></htmltext>
<tokenext>the solar system is a program of physics .
a child understanding the program enough to alter a simulation of it makes the claim of the child having no programming experience quite questionable.go tell someone else , marketing droid .
F # stinks .</tokentext>
<sentencetext>the solar system is a program of physics.
a child understanding the program enough to alter a simulation of it makes the claim of the child having no programming experience quite questionable.go tell someone else, marketing droid.
F# stinks.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051246</id>
	<title>What might f otherwise be for?</title>
	<author>Anonymous</author>
	<datestamp>1265539500000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>Something tells me F will mean something completely different when youre getting compiler errors or crashes.</p></div><p>fgrep??</p></div>
	</htmltext>
<tokenext>Something tells me F will mean something completely different when youre getting compiler errors or crashes.fgrep ?
?</tokentext>
<sentencetext>Something tells me F will mean something completely different when youre getting compiler errors or crashes.fgrep?
?
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050964</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051208</id>
	<title>F# for Scientists?!</title>
	<author>Anonymous</author>
	<datestamp>1265538660000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Hmm...Amazon says he consulted on the book. Wouldn't be a problem except the author is one of the most notorious trolls in the FP community! Way to go, Microsoft PR! Maybe you guys can hook Derek Smart up with someone in the games division?</p></htmltext>
<tokenext>Hmm...Amazon says he consulted on the book .
Would n't be a problem except the author is one of the most notorious trolls in the FP community !
Way to go , Microsoft PR !
Maybe you guys can hook Derek Smart up with someone in the games division ?</tokentext>
<sentencetext>Hmm...Amazon says he consulted on the book.
Wouldn't be a problem except the author is one of the most notorious trolls in the FP community!
Way to go, Microsoft PR!
Maybe you guys can hook Derek Smart up with someone in the games division?</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051656</id>
	<title>It's not Microsoft RESEARCH's offering...</title>
	<author>Anonymous</author>
	<datestamp>1265546700000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>2</modscore>
	<htmltext><p>...of a functional language, it is simply Microsoft's offering of a functional language.  The former statement sounds like it's one of the dozens of functional languages fostered in academia, for academia to play with.  The whole difference here is that, as of Visual Studio 2010, F# becomes a fully productized and supported language in the<nobr> <wbr></nobr>.NET world.  That's really what's exciting for functional language geeks, because never before a real, modern functional language of the generation built in academia in the 90s, like OCaml and Haskell, had such a mainstream backing.</p></htmltext>
<tokenext>...of a functional language , it is simply Microsoft 's offering of a functional language .
The former statement sounds like it 's one of the dozens of functional languages fostered in academia , for academia to play with .
The whole difference here is that , as of Visual Studio 2010 , F # becomes a fully productized and supported language in the .NET world .
That 's really what 's exciting for functional language geeks , because never before a real , modern functional language of the generation built in academia in the 90s , like OCaml and Haskell , had such a mainstream backing .</tokentext>
<sentencetext>...of a functional language, it is simply Microsoft's offering of a functional language.
The former statement sounds like it's one of the dozens of functional languages fostered in academia, for academia to play with.
The whole difference here is that, as of Visual Studio 2010, F# becomes a fully productized and supported language in the .NET world.
That's really what's exciting for functional language geeks, because never before a real, modern functional language of the generation built in academia in the 90s, like OCaml and Haskell, had such a mainstream backing.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051648</id>
	<title>Two great tastes that taste good together?</title>
	<author>argent</author>
	<datestamp>1265546580000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><i>nothing beats the uses of F# to implement statistical machine learning algorithms as part of the Bing advertisement delivery machinery</i></p><p>Are you SURE you want to promote that as a productive use of the language? Bring together two things that people love to hate? Even Google's ads are merely tolerated at best.</p><p>What's next, "F# for spammers"?</p></htmltext>
<tokenext>nothing beats the uses of F # to implement statistical machine learning algorithms as part of the Bing advertisement delivery machineryAre you SURE you want to promote that as a productive use of the language ?
Bring together two things that people love to hate ?
Even Google 's ads are merely tolerated at best.What 's next , " F # for spammers " ?</tokentext>
<sentencetext>nothing beats the uses of F# to implement statistical machine learning algorithms as part of the Bing advertisement delivery machineryAre you SURE you want to promote that as a productive use of the language?
Bring together two things that people love to hate?
Even Google's ads are merely tolerated at best.What's next, "F# for spammers"?</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051610</id>
	<title>Helloworld</title>
	<author>Anonymous</author>
	<datestamp>1265545740000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>For those who don't have a clue but still have urge to comment, here is "hello world" in F#:</p><p>[start snipp]</p><p>#light</p><p>open System</p><p>printfn "Hello world\n"</p><p>Console.ReadKey(true)</p><p>[end snipp]</p><p>And another example illustrating what would would take a highschool kid to modify physics simulation:</p><p>[start snipp]</p><p>#light</p><p>open System</p><p>let gravity = -9.81</p><p>let euler\_explicit accel pos speed delta =<br>pos + delta * speed, speed + delta * accel</p><p>let euler\_implicit accel pos speed delta =<br>let speed2 = speed + delta * accel in<br>pos + delta * speed2, speed2</p><p>let pos, speed = euler\_explicit gravity 0.0 0.0 1.0 in<br>printfn "pos = \%f speed = \%f\n" pos speed</p><p>let pos, speed = euler\_implicit gravity 0.0 0.0 1.0 in<br>printfn "pos = \%f speed = \%f\n" pos speed</p><p>Console.ReadKey(true)</p><p>[end snipp]</p><p>(taken from <a href="http://sharp-gamedev.blogspot.com/2008\_09\_01\_archive.html" title="blogspot.com" rel="nofollow">http://sharp-gamedev.blogspot.com/2008\_09\_01\_archive.html</a> [blogspot.com])</p><p>Cheers</p></htmltext>
<tokenext>For those who do n't have a clue but still have urge to comment , here is " hello world " in F # : [ start snipp ] # lightopen Systemprintfn " Hello world \ n " Console.ReadKey ( true ) [ end snipp ] And another example illustrating what would would take a highschool kid to modify physics simulation : [ start snipp ] # lightopen Systemlet gravity = -9.81let euler \ _explicit accel pos speed delta = pos + delta * speed , speed + delta * accellet euler \ _implicit accel pos speed delta = let speed2 = speed + delta * accel inpos + delta * speed2 , speed2let pos , speed = euler \ _explicit gravity 0.0 0.0 1.0 inprintfn " pos = \ % f speed = \ % f \ n " pos speedlet pos , speed = euler \ _implicit gravity 0.0 0.0 1.0 inprintfn " pos = \ % f speed = \ % f \ n " pos speedConsole.ReadKey ( true ) [ end snipp ] ( taken from http : //sharp-gamedev.blogspot.com/2008 \ _09 \ _01 \ _archive.html [ blogspot.com ] ) Cheers</tokentext>
<sentencetext>For those who don't have a clue but still have urge to comment, here is "hello world" in F#:[start snipp]#lightopen Systemprintfn "Hello world\n"Console.ReadKey(true)[end snipp]And another example illustrating what would would take a highschool kid to modify physics simulation:[start snipp]#lightopen Systemlet gravity = -9.81let euler\_explicit accel pos speed delta =pos + delta * speed, speed + delta * accellet euler\_implicit accel pos speed delta =let speed2 = speed + delta * accel inpos + delta * speed2, speed2let pos, speed = euler\_explicit gravity 0.0 0.0 1.0 inprintfn "pos = \%f speed = \%f\n" pos speedlet pos, speed = euler\_implicit gravity 0.0 0.0 1.0 inprintfn "pos = \%f speed = \%f\n" pos speedConsole.ReadKey(true)[end snipp](taken from http://sharp-gamedev.blogspot.com/2008\_09\_01\_archive.html [blogspot.com])Cheers</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31053178</id>
	<title>Re:F is for Fun?</title>
	<author>Dirtside</author>
	<datestamp>1265566860000</datestamp>
	<modclass>Funny</modclass>
	<modscore>4</modscore>
	<htmltext><p>F# is an abbreviation -- the language's full name is F#$@!</p></htmltext>
<tokenext>F # is an abbreviation -- the language 's full name is F # $ @ !</tokentext>
<sentencetext>F# is an abbreviation -- the language's full name is F#$@!</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050964</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051088</id>
	<title>What's wrong with C and Python?</title>
	<author>Anonymous</author>
	<datestamp>1265535600000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>If I want something done fast I code in python. When I want something fast done I code in C. They are perfect for what I need to do.</p></htmltext>
<tokenext>If I want something done fast I code in python .
When I want something fast done I code in C. They are perfect for what I need to do .</tokentext>
<sentencetext>If I want something done fast I code in python.
When I want something fast done I code in C. They are perfect for what I need to do.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31052426</id>
	<title>Re:Looks interesting as replacement for Python</title>
	<author>Anonymous</author>
	<datestamp>1265558520000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>I prefer OCaml's syntax over that of F# then:</p><p>let rec factorial = function 0 -&gt; 1 | n -&gt; n * factorial (n - 1)</p></htmltext>
<tokenext>I prefer OCaml 's syntax over that of F # then : let rec factorial = function 0 - &gt; 1 | n - &gt; n * factorial ( n - 1 )</tokentext>
<sentencetext>I prefer OCaml's syntax over that of F# then:let rec factorial = function 0 -&gt; 1 | n -&gt; n * factorial (n - 1)</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051780</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050984</id>
	<title>Checkbox marketing</title>
	<author>Anonymous</author>
	<datestamp>1265576100000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>4</modscore>
	<htmltext><blockquote><div><p>F# for Scientists<nobr> <wbr></nobr>... F# in the finance industry<nobr> <wbr></nobr>... F#<nobr> <wbr></nobr>... statistical machine learning algorithms<nobr> <wbr></nobr>... solar system simulator</p></div></blockquote><p>and the emotive language and buzzwords</p><blockquote><div><p>compelling<nobr> <wbr></nobr>... impact<nobr> <wbr></nobr>... convincing<nobr> <wbr></nobr>... advertisement delivery machinery<nobr> <wbr></nobr>... simple and intuitive</p></div></blockquote><p>*yawn* unconvinced.</p></div>
	</htmltext>
<tokenext>F # for Scientists ... F # in the finance industry ... F # ... statistical machine learning algorithms ... solar system simulatorand the emotive language and buzzwordscompelling ... impact ... convincing ... advertisement delivery machinery ... simple and intuitive * yawn * unconvinced .</tokentext>
<sentencetext>F# for Scientists ... F# in the finance industry ... F# ... statistical machine learning algorithms ... solar system simulatorand the emotive language and buzzwordscompelling ... impact ... convincing ... advertisement delivery machinery ... simple and intuitive*yawn* unconvinced.
	</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051350</id>
	<title>Re:Not even going to RTFA</title>
	<author>0ld\_d0g</author>
	<datestamp>1265541180000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>even<nobr> <wbr></nobr>.NET is ripping off Java</p></div><p>Thats like saying Linux just ripped of Minix/Unix. All your comment shows is that you have little to no clue of what<nobr> <wbr></nobr>.NET is. The primary way to do innovation is to take existing technologies and build upon it and improve it. Which is why software patents suck ass.</p><p><div class="quote"><p>Why can't they just inter-operate and integrate with outside software?</p></div><p>They can. They however don't want to (or need to), because then they lose control over it.</p></div>
	</htmltext>
<tokenext>even .NET is ripping off JavaThats like saying Linux just ripped of Minix/Unix .
All your comment shows is that you have little to no clue of what .NET is .
The primary way to do innovation is to take existing technologies and build upon it and improve it .
Which is why software patents suck ass.Why ca n't they just inter-operate and integrate with outside software ? They can .
They however do n't want to ( or need to ) , because then they lose control over it .</tokentext>
<sentencetext>even .NET is ripping off JavaThats like saying Linux just ripped of Minix/Unix.
All your comment shows is that you have little to no clue of what .NET is.
The primary way to do innovation is to take existing technologies and build upon it and improve it.
Which is why software patents suck ass.Why can't they just inter-operate and integrate with outside software?They can.
They however don't want to (or need to), because then they lose control over it.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051250</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31064918</id>
	<title>Re:Anyone else think is was a .NET Fortran?</title>
	<author>Anonymous</author>
	<datestamp>1265623380000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext>Fortran is a procedural language, not a functional one.</htmltext>
<tokenext>Fortran is a procedural language , not a functional one .</tokentext>
<sentencetext>Fortran is a procedural language, not a functional one.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050952</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31052620</id>
	<title>Re:Functional languages and recursion</title>
	<author>chico\_the\_chihuahua</author>
	<datestamp>1265560860000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Probably because it's easier to express, recognise and optimise tail-recursion under the functional paradigm than the imperative space, especially true for the close-to-metal languages like C/C++.</p><p>Funnily enough though, I may be wrong about this, but I don't believe that the IL has very good at tail recursive performance, so proper tail recursion is only used after some stack usage heuristic has been breached....<br>
&nbsp;</p></htmltext>
<tokenext>Probably because it 's easier to express , recognise and optimise tail-recursion under the functional paradigm than the imperative space , especially true for the close-to-metal languages like C/C + + .Funnily enough though , I may be wrong about this , but I do n't believe that the IL has very good at tail recursive performance , so proper tail recursion is only used after some stack usage heuristic has been breached... .  </tokentext>
<sentencetext>Probably because it's easier to express, recognise and optimise tail-recursion under the functional paradigm than the imperative space, especially true for the close-to-metal languages like C/C++.Funnily enough though, I may be wrong about this, but I don't believe that the IL has very good at tail recursive performance, so proper tail recursion is only used after some stack usage heuristic has been breached....
 </sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31052224</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051176</id>
	<title>It is, kind of</title>
	<author>\_merlin</author>
	<datestamp>1265538000000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>2</modscore>
	<htmltext><p>FORTRAN has dug itself into a corner where it survives quite nicely.  It's used for mathematical, engineering and scientific libraries.  FORTRAN just seems to lend itself to expressing these sorts of problems better.  Mind you, the whole program probably won't be written in FORTRAN - any UI code and other glue will be written in C.  F# is filling the same niche for<nobr> <wbr></nobr>.NET - the mathematical and analytic  libraries are being written in F# while C# is used for UIs and other glue.  So even if it's a completely different paradigm, in spirit it's the FORTRAN of the CLR.</p></htmltext>
<tokenext>FORTRAN has dug itself into a corner where it survives quite nicely .
It 's used for mathematical , engineering and scientific libraries .
FORTRAN just seems to lend itself to expressing these sorts of problems better .
Mind you , the whole program probably wo n't be written in FORTRAN - any UI code and other glue will be written in C. F # is filling the same niche for .NET - the mathematical and analytic libraries are being written in F # while C # is used for UIs and other glue .
So even if it 's a completely different paradigm , in spirit it 's the FORTRAN of the CLR .</tokentext>
<sentencetext>FORTRAN has dug itself into a corner where it survives quite nicely.
It's used for mathematical, engineering and scientific libraries.
FORTRAN just seems to lend itself to expressing these sorts of problems better.
Mind you, the whole program probably won't be written in FORTRAN - any UI code and other glue will be written in C.  F# is filling the same niche for .NET - the mathematical and analytic  libraries are being written in F# while C# is used for UIs and other glue.
So even if it's a completely different paradigm, in spirit it's the FORTRAN of the CLR.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050952</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31052008</id>
	<title>Re:.NET Framework</title>
	<author>maxume</author>
	<datestamp>1265553300000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>There really isn't anything very interesting about the lambda statement in python.</p><p>(all objects in python are first class, so you can use a named function anywhere you can use a lambda, and lambdas are restricted to a single expression)</p></htmltext>
<tokenext>There really is n't anything very interesting about the lambda statement in python .
( all objects in python are first class , so you can use a named function anywhere you can use a lambda , and lambdas are restricted to a single expression )</tokentext>
<sentencetext>There really isn't anything very interesting about the lambda statement in python.
(all objects in python are first class, so you can use a named function anywhere you can use a lambda, and lambdas are restricted to a single expression)</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051062</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31052158</id>
	<title>What About Functional C#?</title>
	<author>Doc Ruby</author>
	<datestamp>1265555400000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Aren't all the functional techniques in F# being pulled into C#? Like DryadLINQ, and other components from Microsoft?</p></htmltext>
<tokenext>Are n't all the functional techniques in F # being pulled into C # ?
Like DryadLINQ , and other components from Microsoft ?</tokentext>
<sentencetext>Aren't all the functional techniques in F# being pulled into C#?
Like DryadLINQ, and other components from Microsoft?</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31052384</id>
	<title>Re:Functional languages and recursion</title>
	<author>ascari</author>
	<datestamp>1265558100000</datestamp>
	<modclass>Funny</modclass>
	<modscore>2</modscore>
	<htmltext><p><div class="quote"><p>Why are most programmers uncomfortable with it?</p></div><p>
Possible because:<br>
n1=1<br>
n2=2<br>
n3=6<br>
n4=24<br>
n5= "Segmentation fault. Core dump"
</p><p><div class="quote"><p>What can be done to break this cycle?</p></div><p>Try this:<br>
#define "Segmentation fault. Core dump" 120
</p></div>
	</htmltext>
<tokenext>Why are most programmers uncomfortable with it ?
Possible because : n1 = 1 n2 = 2 n3 = 6 n4 = 24 n5 = " Segmentation fault .
Core dump " What can be done to break this cycle ? Try this : # define " Segmentation fault .
Core dump " 120</tokentext>
<sentencetext>Why are most programmers uncomfortable with it?
Possible because:
n1=1
n2=2
n3=6
n4=24
n5= "Segmentation fault.
Core dump"
What can be done to break this cycle?Try this:
#define "Segmentation fault.
Core dump" 120

	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31052224</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31052224</id>
	<title>Functional languages and recursion</title>
	<author>Anonymous</author>
	<datestamp>1265556240000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>If this is a functional language, it presumably makes generous use of recursion. Which brings up something I'd be interest in<nobr> <wbr></nobr>/. comments on...

</p><p>There are a lot of algorithms that can best be expressed and (theoretically) most efficiently solved by recursion. However, (a) most programmers are not comfortable with recursion and (b) most programming languages (C++, C#, Java, etc.) make no optimization for recursion. In particular, they use a new stack frame for each recursion, even if the function is tail-recursive. This lack of optimization means that deeply recursive algorithms must be avoided - leading right back to (a).

</p><p>My question for<nobr> <wbr></nobr>/. is simply: why? Why co modern OO languages not provide decent optimizations for recursion? Why are most programmers uncomfortable with it? What can be done to break this cycle?</p></htmltext>
<tokenext>If this is a functional language , it presumably makes generous use of recursion .
Which brings up something I 'd be interest in / .
comments on.. . There are a lot of algorithms that can best be expressed and ( theoretically ) most efficiently solved by recursion .
However , ( a ) most programmers are not comfortable with recursion and ( b ) most programming languages ( C + + , C # , Java , etc .
) make no optimization for recursion .
In particular , they use a new stack frame for each recursion , even if the function is tail-recursive .
This lack of optimization means that deeply recursive algorithms must be avoided - leading right back to ( a ) .
My question for / .
is simply : why ?
Why co modern OO languages not provide decent optimizations for recursion ?
Why are most programmers uncomfortable with it ?
What can be done to break this cycle ?</tokentext>
<sentencetext>If this is a functional language, it presumably makes generous use of recursion.
Which brings up something I'd be interest in /.
comments on...

There are a lot of algorithms that can best be expressed and (theoretically) most efficiently solved by recursion.
However, (a) most programmers are not comfortable with recursion and (b) most programming languages (C++, C#, Java, etc.
) make no optimization for recursion.
In particular, they use a new stack frame for each recursion, even if the function is tail-recursive.
This lack of optimization means that deeply recursive algorithms must be avoided - leading right back to (a).
My question for /.
is simply: why?
Why co modern OO languages not provide decent optimizations for recursion?
Why are most programmers uncomfortable with it?
What can be done to break this cycle?</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31054164</id>
	<title>open source license?</title>
	<author>pydev</author>
	<datestamp>1265575620000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Are you going to make F# available under an open source license like Apache, BSD, or LGPL?  The current shared source license really makes F# unattractive for both commercial and academic use.  Given how much F# builds on OCAML, it would also only seem fair if F# itself becamse open source.</p></htmltext>
<tokenext>Are you going to make F # available under an open source license like Apache , BSD , or LGPL ?
The current shared source license really makes F # unattractive for both commercial and academic use .
Given how much F # builds on OCAML , it would also only seem fair if F # itself becamse open source .</tokentext>
<sentencetext>Are you going to make F# available under an open source license like Apache, BSD, or LGPL?
The current shared source license really makes F# unattractive for both commercial and academic use.
Given how much F# builds on OCAML, it would also only seem fair if F# itself becamse open source.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31056934</id>
	<title>Re:Looks interesting as replacement for Python</title>
	<author>McBeer</author>
	<datestamp>1265554500000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>I agree that Python has some strange things about it, but look at some sample f# syntax from Wikipedia:</p><p>let rec factorial n =</p><p>
&nbsp; &nbsp; &nbsp; &nbsp; match n with</p><p>
&nbsp; &nbsp; &nbsp; &nbsp; | 0I -&gt; 1I</p><p>
&nbsp; &nbsp; &nbsp; &nbsp; | \_ -&gt; n * factorial (n - 1I)</p><p>What do those funny characters mean? What's the I after the numbers? Compare to the python one liner:</p><p>def factorial(n): return 1 if n == 0 else n * factorial (n-1)</p><p>That makes sense even to someone with absolutely zero experience in the language.</p></div><p>The problem here is with wikipedia not F#.  The characters are normally a way of typecasting integer literals, however it it not necessary (nor even valid) to do that in a match statement.  The wikipedia example should be:</p><p>let rec factorial n =</p><p>
&nbsp; &nbsp; &nbsp; &nbsp; match n with</p><p>
&nbsp; &nbsp; &nbsp; &nbsp; | 0 -&gt; 1</p><p>
&nbsp; &nbsp; &nbsp; &nbsp; | \_ -&gt; n * factorial (n - 1)</p><p>or even more simply</p><p>let rec factorial n = if n=0 then 1 else n * factorial (n-1)</p></div>
	</htmltext>
<tokenext>I agree that Python has some strange things about it , but look at some sample f # syntax from Wikipedia : let rec factorial n =         match n with         | 0I - &gt; 1I         | \ _ - &gt; n * factorial ( n - 1I ) What do those funny characters mean ?
What 's the I after the numbers ?
Compare to the python one liner : def factorial ( n ) : return 1 if n = = 0 else n * factorial ( n-1 ) That makes sense even to someone with absolutely zero experience in the language.The problem here is with wikipedia not F # .
The characters are normally a way of typecasting integer literals , however it it not necessary ( nor even valid ) to do that in a match statement .
The wikipedia example should be : let rec factorial n =         match n with         | 0 - &gt; 1         | \ _ - &gt; n * factorial ( n - 1 ) or even more simplylet rec factorial n = if n = 0 then 1 else n * factorial ( n-1 )</tokentext>
<sentencetext>I agree that Python has some strange things about it, but look at some sample f# syntax from Wikipedia:let rec factorial n =
        match n with
        | 0I -&gt; 1I
        | \_ -&gt; n * factorial (n - 1I)What do those funny characters mean?
What's the I after the numbers?
Compare to the python one liner:def factorial(n): return 1 if n == 0 else n * factorial (n-1)That makes sense even to someone with absolutely zero experience in the language.The problem here is with wikipedia not F#.
The characters are normally a way of typecasting integer literals, however it it not necessary (nor even valid) to do that in a match statement.
The wikipedia example should be:let rec factorial n =
        match n with
        | 0 -&gt; 1
        | \_ -&gt; n * factorial (n - 1)or even more simplylet rec factorial n = if n=0 then 1 else n * factorial (n-1)
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051780</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050992</id>
	<title>Specific question? Vague answer!</title>
	<author>Anonymous</author>
	<datestamp>1265576280000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>"[Q] What is the best program you've seen written in F#? [A] A bunch of generalized statements, as though I've never actually seen a program in this language."</p></htmltext>
<tokenext>" [ Q ] What is the best program you 've seen written in F # ?
[ A ] A bunch of generalized statements , as though I 've never actually seen a program in this language .
"</tokentext>
<sentencetext>"[Q] What is the best program you've seen written in F#?
[A] A bunch of generalized statements, as though I've never actually seen a program in this language.
"</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051086</id>
	<title>Re:Checkbox marketing</title>
	<author>Ethanol-fueled</author>
	<datestamp>1265535420000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>2</modscore>
	<htmltext>You forgot <a href="http://en.wikipedia.org/wiki/Multi-paradigm\_programming\_language" title="wikipedia.org" rel="nofollow">"paradigm"</a> [wikipedia.org]. My last shop was a C# shop. Never ceased to amaze me how the programs would prompt for the model number and freeze, then crash and and require a manual(Windows ctrl+alt+delete, of course) process kill before the operator had to enter the model number again.<br> <br>

The impression given to the layman is that Microsoft technologies continue to enable idiocy. Hell, the code I dealt with at Java on Oracle shops was slow as fuck but at least it worked the first time around.</htmltext>
<tokenext>You forgot " paradigm " [ wikipedia.org ] .
My last shop was a C # shop .
Never ceased to amaze me how the programs would prompt for the model number and freeze , then crash and and require a manual ( Windows ctrl + alt + delete , of course ) process kill before the operator had to enter the model number again .
The impression given to the layman is that Microsoft technologies continue to enable idiocy .
Hell , the code I dealt with at Java on Oracle shops was slow as fuck but at least it worked the first time around .</tokentext>
<sentencetext>You forgot "paradigm" [wikipedia.org].
My last shop was a C# shop.
Never ceased to amaze me how the programs would prompt for the model number and freeze, then crash and and require a manual(Windows ctrl+alt+delete, of course) process kill before the operator had to enter the model number again.
The impression given to the layman is that Microsoft technologies continue to enable idiocy.
Hell, the code I dealt with at Java on Oracle shops was slow as fuck but at least it worked the first time around.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050984</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051062</id>
	<title>.NET Framework</title>
	<author>Yuioup</author>
	<datestamp>1265534760000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>5</modscore>
	<htmltext><p>Last year I wanted to know what all the hoopla was about functional programming. I checked out Haskell, Scala, OCaML and F#. Coming from a Java/Delphi/C# background myself I had to go through it a couple of times before I "got" it. I'm glad I did because I banged out my first production IronPython lambda function on last Friday (yay!).</p><p>I know that MS bashing is popular here on Slashdot, but I really want to take a moment to say that the<nobr> <wbr></nobr>.NET Framework really is excellent. The ability to mix and match different paradigms and languages in a clean an concise manner which is a joy to program in.</p><p>Yeah I know patents bla bla mono bla bla Novell bla bla Miguel bla bla.</p></htmltext>
<tokenext>Last year I wanted to know what all the hoopla was about functional programming .
I checked out Haskell , Scala , OCaML and F # .
Coming from a Java/Delphi/C # background myself I had to go through it a couple of times before I " got " it .
I 'm glad I did because I banged out my first production IronPython lambda function on last Friday ( yay !
) .I know that MS bashing is popular here on Slashdot , but I really want to take a moment to say that the .NET Framework really is excellent .
The ability to mix and match different paradigms and languages in a clean an concise manner which is a joy to program in.Yeah I know patents bla bla mono bla bla Novell bla bla Miguel bla bla .</tokentext>
<sentencetext>Last year I wanted to know what all the hoopla was about functional programming.
I checked out Haskell, Scala, OCaML and F#.
Coming from a Java/Delphi/C# background myself I had to go through it a couple of times before I "got" it.
I'm glad I did because I banged out my first production IronPython lambda function on last Friday (yay!
).I know that MS bashing is popular here on Slashdot, but I really want to take a moment to say that the .NET Framework really is excellent.
The ability to mix and match different paradigms and languages in a clean an concise manner which is a joy to program in.Yeah I know patents bla bla mono bla bla Novell bla bla Miguel bla bla.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31066610</id>
	<title>Re:Object oriented and functional cannot be combin</title>
	<author>Anonymous</author>
	<datestamp>1265630100000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>In what sense is the set of values for the function type "int -&gt; int" closed?  The set encompasses all possible computable integer-to-integer functions. That seems like a lot of values.</p><p>Indeed, it seems like exactly the same number of values as the number of objects with a base class with an abstract member taking an integer and returning an integer.</p><p>In other words, what is you definition of "closed?", particularly for function types?</p></htmltext>
<tokenext>In what sense is the set of values for the function type " int - &gt; int " closed ?
The set encompasses all possible computable integer-to-integer functions .
That seems like a lot of values.Indeed , it seems like exactly the same number of values as the number of objects with a base class with an abstract member taking an integer and returning an integer.In other words , what is you definition of " closed ?
" , particularly for function types ?</tokentext>
<sentencetext>In what sense is the set of values for the function type "int -&gt; int" closed?
The set encompasses all possible computable integer-to-integer functions.
That seems like a lot of values.Indeed, it seems like exactly the same number of values as the number of objects with a base class with an abstract member taking an integer and returning an integer.In other words, what is you definition of "closed?
", particularly for function types?</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31055248</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050946</id>
	<title>There going to run out of musical notes soon...</title>
	<author>Anonymous</author>
	<datestamp>1265575260000</datestamp>
	<modclass>Funny</modclass>
	<modscore>4</modscore>
	<htmltext>Will D flat be the same language as c#?</htmltext>
<tokenext>Will D flat be the same language as c # ?</tokentext>
<sentencetext>Will D flat be the same language as c#?</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051916</id>
	<title>Re:Looks interesting as replacement for Python</title>
	<author>Anonymous</author>
	<datestamp>1265551620000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>If you have ever done a substantial amount of code that works on ranges, using operations such as finding common subranges, unifying multiple ranges, determining complementary ranges etc., then you learn to appreciate the style of leaving the specified endpoint outside the range.  Otherwise you simply end up doing lots of +1 or -1 adjustments to get all the comparisons and iterations correct (and no, often you can't work around it by using a less-than-or-equal comparison).  And if you miss a single adjustment, you get a hard-to-find bug.  On the other hand, using ranges where the endpoint is not included is much easier, and you hardly ever need to do any adjustments to the endpoints at all.</p></htmltext>
<tokenext>If you have ever done a substantial amount of code that works on ranges , using operations such as finding common subranges , unifying multiple ranges , determining complementary ranges etc. , then you learn to appreciate the style of leaving the specified endpoint outside the range .
Otherwise you simply end up doing lots of + 1 or -1 adjustments to get all the comparisons and iterations correct ( and no , often you ca n't work around it by using a less-than-or-equal comparison ) .
And if you miss a single adjustment , you get a hard-to-find bug .
On the other hand , using ranges where the endpoint is not included is much easier , and you hardly ever need to do any adjustments to the endpoints at all .</tokentext>
<sentencetext>If you have ever done a substantial amount of code that works on ranges, using operations such as finding common subranges, unifying multiple ranges, determining complementary ranges etc., then you learn to appreciate the style of leaving the specified endpoint outside the range.
Otherwise you simply end up doing lots of +1 or -1 adjustments to get all the comparisons and iterations correct (and no, often you can't work around it by using a less-than-or-equal comparison).
And if you miss a single adjustment, you get a hard-to-find bug.
On the other hand, using ranges where the endpoint is not included is much easier, and you hardly ever need to do any adjustments to the endpoints at all.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051356</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051952</id>
	<title>Re:Looks interesting as replacement for Python</title>
	<author>Anonymous</author>
	<datestamp>1265552340000</datestamp>
	<modclass>Informativ</modclass>
	<modscore>1</modscore>
	<htmltext><p>I've never used F# but that syntax is very clear as long as you understand pattern matching.  Furthermore, the F# version won't cause a stack overflow for large values of n where the Python version will.</p></htmltext>
<tokenext>I 've never used F # but that syntax is very clear as long as you understand pattern matching .
Furthermore , the F # version wo n't cause a stack overflow for large values of n where the Python version will .</tokentext>
<sentencetext>I've never used F# but that syntax is very clear as long as you understand pattern matching.
Furthermore, the F# version won't cause a stack overflow for large values of n where the Python version will.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051780</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31052414</id>
	<title>Re:Looks interesting as replacement for Python</title>
	<author>Anonymous</author>
	<datestamp>1265558400000</datestamp>
	<modclass>Flamebait</modclass>
	<modscore>-1</modscore>
	<htmltext><p>Well, "match n with" sounds like a description of "case" to me. And lo! There are "|" and "-&gt;"s that imply this even more! All integers have "I" after them -- crazy! Unless, of course, you've worked in any other C derived language and seen "f"s after floating point numbers. In that case, it's a very minor mental step. Finally, "\_". Why is there an underscore there? Well, our case statement has no default, I'm guessing that means default.</p><p>Wow, that was easy. Maybe you've been staring at Python code too long, and should get out and try something new? I might consider benchmarking F# and Python for a start, and seeing if you can't find a way to justify using F# sometimes (hint: it will beat the ever-loving tar out of Python on any traditionally "functional" task).</p></htmltext>
<tokenext>Well , " match n with " sounds like a description of " case " to me .
And lo !
There are " | " and " - &gt; " s that imply this even more !
All integers have " I " after them -- crazy !
Unless , of course , you 've worked in any other C derived language and seen " f " s after floating point numbers .
In that case , it 's a very minor mental step .
Finally , " \ _ " .
Why is there an underscore there ?
Well , our case statement has no default , I 'm guessing that means default.Wow , that was easy .
Maybe you 've been staring at Python code too long , and should get out and try something new ?
I might consider benchmarking F # and Python for a start , and seeing if you ca n't find a way to justify using F # sometimes ( hint : it will beat the ever-loving tar out of Python on any traditionally " functional " task ) .</tokentext>
<sentencetext>Well, "match n with" sounds like a description of "case" to me.
And lo!
There are "|" and "-&gt;"s that imply this even more!
All integers have "I" after them -- crazy!
Unless, of course, you've worked in any other C derived language and seen "f"s after floating point numbers.
In that case, it's a very minor mental step.
Finally, "\_".
Why is there an underscore there?
Well, our case statement has no default, I'm guessing that means default.Wow, that was easy.
Maybe you've been staring at Python code too long, and should get out and try something new?
I might consider benchmarking F# and Python for a start, and seeing if you can't find a way to justify using F# sometimes (hint: it will beat the ever-loving tar out of Python on any traditionally "functional" task).</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051780</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31059414</id>
	<title>F#'s main weakness is the .Net.</title>
	<author>Anonymous</author>
	<datestamp>1265630700000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>F# does contain holes in its type system.<p>

I've <a href="http://rsdn.ru/forum/decl/3405105.aspx" title="rsdn.ru" rel="nofollow">read</a> [rsdn.ru] (Russian) that the following code crashes in runtime:</p><p><div class="quote"><p>let comp x y = x &gt; y<br>let result = comp (new Dictionary&lt;object, object&gt;) (new Dictionary&lt;object, object&gt;)</p></div><p>(I am not an F# expert, I am a Haskell user;)</p></div>
	</htmltext>
<tokenext>F # does contain holes in its type system .
I 've read [ rsdn.ru ] ( Russian ) that the following code crashes in runtime : let comp x y = x &gt; ylet result = comp ( new Dictionary ) ( new Dictionary ) ( I am not an F # expert , I am a Haskell user ; )</tokentext>
<sentencetext>F# does contain holes in its type system.
I've read [rsdn.ru] (Russian) that the following code crashes in runtime:let comp x y = x &gt; ylet result = comp (new Dictionary) (new Dictionary)(I am not an F# expert, I am a Haskell user;)
	</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31054868</id>
	<title>Re:Looks interesting as replacement for Python</title>
	<author>Anonymous</author>
	<datestamp>1265537640000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Obviously someone's odd example on a wiki is a good reason why a language is weird..</p><p>here is your python example in F#:<br>ler rec factorial n = if n = 0 then 1 else n * factorial (n-1)</p><p>Looks similar, doesn't it?</p><p>The Wikipedia example tried to show pattern matching for a bit of more information, and the I at the end of numbers is to use "large" integers that grow in size, because factorial of 1000000 would overflow both the python and this F# example, but not the one you saw on wikiepdia because it's using bigints.</p></htmltext>
<tokenext>Obviously someone 's odd example on a wiki is a good reason why a language is weird..here is your python example in F # : ler rec factorial n = if n = 0 then 1 else n * factorial ( n-1 ) Looks similar , does n't it ? The Wikipedia example tried to show pattern matching for a bit of more information , and the I at the end of numbers is to use " large " integers that grow in size , because factorial of 1000000 would overflow both the python and this F # example , but not the one you saw on wikiepdia because it 's using bigints .</tokentext>
<sentencetext>Obviously someone's odd example on a wiki is a good reason why a language is weird..here is your python example in F#:ler rec factorial n = if n = 0 then 1 else n * factorial (n-1)Looks similar, doesn't it?The Wikipedia example tried to show pattern matching for a bit of more information, and the I at the end of numbers is to use "large" integers that grow in size, because factorial of 1000000 would overflow both the python and this F# example, but not the one you saw on wikiepdia because it's using bigints.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051780</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31054220</id>
	<title>Re:Functional languages and recursion</title>
	<author>pydev</author>
	<datestamp>1265576100000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><i>There are a lot of algorithms that can best be expressed and (theoretically) most efficiently solved by recursion. </i></p><p>Whether you use recursion or loops generally makes no difference for asymptotic performance, since they can be easily transformed into one another.  For actual speed, loops are always at least as fast as recursion.</p><p><i>(a) most programmers are not comfortable with recursion</i></p><p>Most programmers don't seem to have a problem with recursion.  They don't like tail recursion, but that's because tail recursion doesn't make a lot of sense in an OOL.</p><p><i>My question for<nobr> <wbr></nobr>/. is simply: why? Why co modern OO languages not provide decent optimizations for recursion?  Why are most programmers uncomfortable with it? What can be done to break this cycle?</i></p><p>Tail recursion makes most sense if you want to avoid assignment.  Since OOLs have assignment, often a loop is just the better construct.  Most other kinds of recursion can't be optimized anyway.</p><p>FWIW, gcc does support tail recursion optimization.  Of course, if you rely on it, your program may not run as well on other compilers.</p></htmltext>
<tokenext>There are a lot of algorithms that can best be expressed and ( theoretically ) most efficiently solved by recursion .
Whether you use recursion or loops generally makes no difference for asymptotic performance , since they can be easily transformed into one another .
For actual speed , loops are always at least as fast as recursion .
( a ) most programmers are not comfortable with recursionMost programmers do n't seem to have a problem with recursion .
They do n't like tail recursion , but that 's because tail recursion does n't make a lot of sense in an OOL.My question for / .
is simply : why ?
Why co modern OO languages not provide decent optimizations for recursion ?
Why are most programmers uncomfortable with it ?
What can be done to break this cycle ? Tail recursion makes most sense if you want to avoid assignment .
Since OOLs have assignment , often a loop is just the better construct .
Most other kinds of recursion ca n't be optimized anyway.FWIW , gcc does support tail recursion optimization .
Of course , if you rely on it , your program may not run as well on other compilers .</tokentext>
<sentencetext>There are a lot of algorithms that can best be expressed and (theoretically) most efficiently solved by recursion.
Whether you use recursion or loops generally makes no difference for asymptotic performance, since they can be easily transformed into one another.
For actual speed, loops are always at least as fast as recursion.
(a) most programmers are not comfortable with recursionMost programmers don't seem to have a problem with recursion.
They don't like tail recursion, but that's because tail recursion doesn't make a lot of sense in an OOL.My question for /.
is simply: why?
Why co modern OO languages not provide decent optimizations for recursion?
Why are most programmers uncomfortable with it?
What can be done to break this cycle?Tail recursion makes most sense if you want to avoid assignment.
Since OOLs have assignment, often a loop is just the better construct.
Most other kinds of recursion can't be optimized anyway.FWIW, gcc does support tail recursion optimization.
Of course, if you rely on it, your program may not run as well on other compilers.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31052224</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31053482</id>
	<title>Re:Marketing? What the?</title>
	<author>Anonymous</author>
	<datestamp>1265569200000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>I agree. I attended a lecture he gave recently. He is a smart guy and F# is solid language.</p></htmltext>
<tokenext>I agree .
I attended a lecture he gave recently .
He is a smart guy and F # is solid language .</tokentext>
<sentencetext>I agree.
I attended a lecture he gave recently.
He is a smart guy and F# is solid language.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051576</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31055470</id>
	<title>Re:Looks interesting as replacement for Python</title>
	<author>Anonymous</author>
	<datestamp>1265541480000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>This is example of mathers, often they looks better when there are five or more nodes... And of course, F# also has if...else.. So I believe your example is lack of imagination.</p></htmltext>
<tokenext>This is example of mathers , often they looks better when there are five or more nodes... And of course , F # also has if...else.. So I believe your example is lack of imagination .</tokentext>
<sentencetext>This is example of mathers, often they looks better when there are five or more nodes... And of course, F# also has if...else.. So I believe your example is lack of imagination.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051780</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31054392</id>
	<title>Re:Python is waaaayyy better</title>
	<author>otter42</author>
	<datestamp>1265534220000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><i>You say you don't like 'len' as a name for a length function, that you would prefer using the name 'length'. Well, python is so superior, that you can fix that problem really fast in your code:</i></p><p><i>length = len</i></p><p>That *is* a neat feature.</p><p>My only beef is that it can't help to solve the mess that is everyone else's Python code. Once I'm programming in Python, all these things will seem very natural. (It can't be worse than C!) But for people who are new to Python, and just want to modify a tiny section of code in someone's script because it almost, but not quite, does what they want it to, all the myriad Python bizarreness jumps up and bites them.</p></htmltext>
<tokenext>You say you do n't like 'len ' as a name for a length function , that you would prefer using the name 'length' .
Well , python is so superior , that you can fix that problem really fast in your code : length = lenThat * is * a neat feature.My only beef is that it ca n't help to solve the mess that is everyone else 's Python code .
Once I 'm programming in Python , all these things will seem very natural .
( It ca n't be worse than C !
) But for people who are new to Python , and just want to modify a tiny section of code in someone 's script because it almost , but not quite , does what they want it to , all the myriad Python bizarreness jumps up and bites them .</tokentext>
<sentencetext>You say you don't like 'len' as a name for a length function, that you would prefer using the name 'length'.
Well, python is so superior, that you can fix that problem really fast in your code:length = lenThat *is* a neat feature.My only beef is that it can't help to solve the mess that is everyone else's Python code.
Once I'm programming in Python, all these things will seem very natural.
(It can't be worse than C!
) But for people who are new to Python, and just want to modify a tiny section of code in someone's script because it almost, but not quite, does what they want it to, all the myriad Python bizarreness jumps up and bites them.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31052848</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31053394</id>
	<title>Re:Looks interesting as replacement for Python</title>
	<author>Anonymous</author>
	<datestamp>1265568660000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>"Funny characters"?  You can pretty much guess what they mean by looking at them, if you have any experience in programing *at all*!</p><p>"I" means "integer"<br>"|" means "or"<br>"-&gt;" means "then"</p><p>Is this really that fucking hard to learn?</p></htmltext>
<tokenext>" Funny characters " ?
You can pretty much guess what they mean by looking at them , if you have any experience in programing * at all * !
" I " means " integer " " | " means " or " " - &gt; " means " then " Is this really that fucking hard to learn ?</tokentext>
<sentencetext>"Funny characters"?
You can pretty much guess what they mean by looking at them, if you have any experience in programing *at all*!
"I" means "integer""|" means "or""-&gt;" means "then"Is this really that fucking hard to learn?</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051780</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31052348</id>
	<title>Re:Anyone else think is was a .NET Fortran?</title>
	<author>MoeDrippins</author>
	<datestamp>1265557680000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>In reality it's just a<nobr> <wbr></nobr>.net version of Ocaml.  Not that that's bad, mind you, but it's hardly revolutionary, or even innovative.</p><p>I will give them props for doing it though; I'm surprised Microsoft would bankroll anything related to functional programming for at least 8 years from now.</p></htmltext>
<tokenext>In reality it 's just a .net version of Ocaml .
Not that that 's bad , mind you , but it 's hardly revolutionary , or even innovative.I will give them props for doing it though ; I 'm surprised Microsoft would bankroll anything related to functional programming for at least 8 years from now .</tokentext>
<sentencetext>In reality it's just a .net version of Ocaml.
Not that that's bad, mind you, but it's hardly revolutionary, or even innovative.I will give them props for doing it though; I'm surprised Microsoft would bankroll anything related to functional programming for at least 8 years from now.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050952</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31054292</id>
	<title>Re:Looks interesting as replacement for Python</title>
	<author>Anonymous</author>
	<datestamp>1265533560000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>In this case, you could use if/else in F# (or ML, Haskell, etc) and it would look very much like the Python version (although the test goes first, not in the middle), but it's more common to define functions case-wise (i.e. pattern-match on the arguments). Partly because that's the convention in mathematics, partly because pattern-matching is more general (using if/else only works when you only have two cases and one of them is "everything else").</p><p>Although the simple base-case/inductive-case form is quite common, so is the situation with two base cases (e.g. empty list, single-element list, arbitrary list, or zero, one, many), or base/inductive for two arguments (giving four cases).</p></htmltext>
<tokenext>In this case , you could use if/else in F # ( or ML , Haskell , etc ) and it would look very much like the Python version ( although the test goes first , not in the middle ) , but it 's more common to define functions case-wise ( i.e .
pattern-match on the arguments ) .
Partly because that 's the convention in mathematics , partly because pattern-matching is more general ( using if/else only works when you only have two cases and one of them is " everything else " ) .Although the simple base-case/inductive-case form is quite common , so is the situation with two base cases ( e.g .
empty list , single-element list , arbitrary list , or zero , one , many ) , or base/inductive for two arguments ( giving four cases ) .</tokentext>
<sentencetext>In this case, you could use if/else in F# (or ML, Haskell, etc) and it would look very much like the Python version (although the test goes first, not in the middle), but it's more common to define functions case-wise (i.e.
pattern-match on the arguments).
Partly because that's the convention in mathematics, partly because pattern-matching is more general (using if/else only works when you only have two cases and one of them is "everything else").Although the simple base-case/inductive-case form is quite common, so is the situation with two base cases (e.g.
empty list, single-element list, arbitrary list, or zero, one, many), or base/inductive for two arguments (giving four cases).</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051780</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31056276</id>
	<title>Re:The optimal blend...</title>
	<author>ralphbecket</author>
	<datestamp>1265547960000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I find it hard to believe you actually understood what you were doing with functional programming.</p><p>FPLs have, for decades, offered a level of safety, precision, and brevity that simply hasn't been matched in any imperative language.  For my money, OO has mainly been a poor-man's effort at adding limited polymorphism to imperative languages.</p><p>I code daily in a range of these languages (functional/logical, imperative, OO) and the amount of verbiage required to do the simplest things in the non-functional languages never ceases to amaze me.  Plus, I have nothing like the faith in the OO and imperative programs that experience has given me with functional languages - that is, the vast majority of my functional programs do exactly what I intend them to do first time.</p></htmltext>
<tokenext>I find it hard to believe you actually understood what you were doing with functional programming.FPLs have , for decades , offered a level of safety , precision , and brevity that simply has n't been matched in any imperative language .
For my money , OO has mainly been a poor-man 's effort at adding limited polymorphism to imperative languages.I code daily in a range of these languages ( functional/logical , imperative , OO ) and the amount of verbiage required to do the simplest things in the non-functional languages never ceases to amaze me .
Plus , I have nothing like the faith in the OO and imperative programs that experience has given me with functional languages - that is , the vast majority of my functional programs do exactly what I intend them to do first time .</tokentext>
<sentencetext>I find it hard to believe you actually understood what you were doing with functional programming.FPLs have, for decades, offered a level of safety, precision, and brevity that simply hasn't been matched in any imperative language.
For my money, OO has mainly been a poor-man's effort at adding limited polymorphism to imperative languages.I code daily in a range of these languages (functional/logical, imperative, OO) and the amount of verbiage required to do the simplest things in the non-functional languages never ceases to amaze me.
Plus, I have nothing like the faith in the OO and imperative programs that experience has given me with functional languages - that is, the vast majority of my functional programs do exactly what I intend them to do first time.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051076</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31053556</id>
	<title>Re:The optimal blend...</title>
	<author>tepples</author>
	<datestamp>1265569980000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>natural languages have features that make some more primitive than others.</p></div><p>What makes you think this?</p></div>
	</htmltext>
<tokenext>natural languages have features that make some more primitive than others.What makes you think this ?</tokentext>
<sentencetext>natural languages have features that make some more primitive than others.What makes you think this?
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051076</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051150</id>
	<title>Re:F is for Fun?</title>
	<author>giuseppemag</author>
	<datestamp>1265536980000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext>The idea is that functional languages tend to exclude by construction certain classes of bugs which are more easily created when writing apparently innocent imperative code.

This is especially believed when dealing with more "unusual" domains such as parallel/concurrent programs.

So the "F for FUN" should be encountered more often than the "F for FUXX"<nobr> <wbr></nobr>:)</htmltext>
<tokenext>The idea is that functional languages tend to exclude by construction certain classes of bugs which are more easily created when writing apparently innocent imperative code .
This is especially believed when dealing with more " unusual " domains such as parallel/concurrent programs .
So the " F for FUN " should be encountered more often than the " F for FUXX " : )</tokentext>
<sentencetext>The idea is that functional languages tend to exclude by construction certain classes of bugs which are more easily created when writing apparently innocent imperative code.
This is especially believed when dealing with more "unusual" domains such as parallel/concurrent programs.
So the "F for FUN" should be encountered more often than the "F for FUXX" :)</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050964</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051196</id>
	<title>Re:The optimal blend...</title>
	<author>shutdown -p now</author>
	<datestamp>1265538480000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>3</modscore>
	<htmltext><p><div class="quote"><p>Functional-based programming languages are syntactically inferior to OO ones</p></div><p>Most likely just the ones that you've seen, and for the tasks you've thrown at them. I wouldn't write a line-of-business application in F#, sure, but I wouldn't write a parser in C# either.</p><p>While we're at syntax - I've yet to see any non-hybrid OO language which has anything matching the power and beauty of classic FP pattern-patching. For any sort of tree processing especially, it's a god send - whereas in OO you have to deal with ugly visitor pattern hack.</p><p>Then also, FP doesn't have to mean "alien syntax", either. Have you seen Scala? It has everything any self-respecting FP language needs to have, yet it's still very much OO-centric, and the syntax is broadly Javaesque.</p><p>To conclude... one of the first two OO languages, and the one to which pretty much all OO languages today owe at least half of their design, is Smalltalk. Coincidentally, it's also a very potent FP language - blocks are nothing but first-class functions, and they were used so pervasively in the language and the standard library that even the most basic conditional statement was actually a method call with two blocks...</p><p>And yet, Smalltalk is considered as one of the most pure OO languages ever.</p><p>Which is to say that OO and FP is really orthogonal, and not at all contradictive. You can have both, and either one is good for something different - so there's no reason <em>not</em> to have both, and get the best of both worlds.</p></div>
	</htmltext>
<tokenext>Functional-based programming languages are syntactically inferior to OO onesMost likely just the ones that you 've seen , and for the tasks you 've thrown at them .
I would n't write a line-of-business application in F # , sure , but I would n't write a parser in C # either.While we 're at syntax - I 've yet to see any non-hybrid OO language which has anything matching the power and beauty of classic FP pattern-patching .
For any sort of tree processing especially , it 's a god send - whereas in OO you have to deal with ugly visitor pattern hack.Then also , FP does n't have to mean " alien syntax " , either .
Have you seen Scala ?
It has everything any self-respecting FP language needs to have , yet it 's still very much OO-centric , and the syntax is broadly Javaesque.To conclude... one of the first two OO languages , and the one to which pretty much all OO languages today owe at least half of their design , is Smalltalk .
Coincidentally , it 's also a very potent FP language - blocks are nothing but first-class functions , and they were used so pervasively in the language and the standard library that even the most basic conditional statement was actually a method call with two blocks...And yet , Smalltalk is considered as one of the most pure OO languages ever.Which is to say that OO and FP is really orthogonal , and not at all contradictive .
You can have both , and either one is good for something different - so there 's no reason not to have both , and get the best of both worlds .</tokentext>
<sentencetext>Functional-based programming languages are syntactically inferior to OO onesMost likely just the ones that you've seen, and for the tasks you've thrown at them.
I wouldn't write a line-of-business application in F#, sure, but I wouldn't write a parser in C# either.While we're at syntax - I've yet to see any non-hybrid OO language which has anything matching the power and beauty of classic FP pattern-patching.
For any sort of tree processing especially, it's a god send - whereas in OO you have to deal with ugly visitor pattern hack.Then also, FP doesn't have to mean "alien syntax", either.
Have you seen Scala?
It has everything any self-respecting FP language needs to have, yet it's still very much OO-centric, and the syntax is broadly Javaesque.To conclude... one of the first two OO languages, and the one to which pretty much all OO languages today owe at least half of their design, is Smalltalk.
Coincidentally, it's also a very potent FP language - blocks are nothing but first-class functions, and they were used so pervasively in the language and the standard library that even the most basic conditional statement was actually a method call with two blocks...And yet, Smalltalk is considered as one of the most pure OO languages ever.Which is to say that OO and FP is really orthogonal, and not at all contradictive.
You can have both, and either one is good for something different - so there's no reason not to have both, and get the best of both worlds.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051076</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051168</id>
	<title>Re:Checkbox marketing</title>
	<author>shutdown -p now</author>
	<datestamp>1265537700000</datestamp>
	<modclass>Informativ</modclass>
	<modscore>3</modscore>
	<htmltext><p>If you don't want the marketing drivel, then the short story is that F# is <a href="http://en.wikipedia.org/wiki/ML\_(programming\_language)" title="wikipedia.org">ML</a> [wikipedia.org] for<nobr> <wbr></nobr>.NET. If you know what that is, you should already know what it's good for, and when you'd want to use it. If you don't know what it is, then you might want to start <a href="http://en.wikipedia.org/wiki/Functional\_programming" title="wikipedia.org">from the basics</a> [wikipedia.org].</p></htmltext>
<tokenext>If you do n't want the marketing drivel , then the short story is that F # is ML [ wikipedia.org ] for .NET .
If you know what that is , you should already know what it 's good for , and when you 'd want to use it .
If you do n't know what it is , then you might want to start from the basics [ wikipedia.org ] .</tokentext>
<sentencetext>If you don't want the marketing drivel, then the short story is that F# is ML [wikipedia.org] for .NET.
If you know what that is, you should already know what it's good for, and when you'd want to use it.
If you don't know what it is, then you might want to start from the basics [wikipedia.org].</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050984</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31053290</id>
	<title>Re:The optimal blend...</title>
	<author>gardyloo</author>
	<datestamp>1265567700000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Funny. I'm just sort of getting into OO-based programming in Python, and it DOES drive me insane, compared to the functional perspective of Mathematica. I find functional languages to be much easier to read, faster to write, and just how I think.</p><p>
&nbsp; &nbsp; &nbsp; I AM happy with Python, and I'm trying to transition to it as my workhorse language.</p></htmltext>
<tokenext>Funny .
I 'm just sort of getting into OO-based programming in Python , and it DOES drive me insane , compared to the functional perspective of Mathematica .
I find functional languages to be much easier to read , faster to write , and just how I think .
      I AM happy with Python , and I 'm trying to transition to it as my workhorse language .</tokentext>
<sentencetext>Funny.
I'm just sort of getting into OO-based programming in Python, and it DOES drive me insane, compared to the functional perspective of Mathematica.
I find functional languages to be much easier to read, faster to write, and just how I think.
      I AM happy with Python, and I'm trying to transition to it as my workhorse language.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051076</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051586</id>
	<title>Re:Looks interesting as replacement for Python</title>
	<author>k33l0r</author>
	<datestamp>1265545260000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>How about you give <a href="http://www.ruby-lang.org/en/" title="ruby-lang.org">Ruby</a> [ruby-lang.org] a try?</htmltext>
<tokenext>How about you give Ruby [ ruby-lang.org ] a try ?</tokentext>
<sentencetext>How about you give Ruby [ruby-lang.org] a try?</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051356</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31053820</id>
	<title>Re:Looks interesting as replacement for Python</title>
	<author>codepunk</author>
	<datestamp>1265572680000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>"Forced whitespacing doesn't suit my debugging style"</p><p>It may not, but it sure makes your crap easier for me to debug when it breaks.</p></htmltext>
<tokenext>" Forced whitespacing does n't suit my debugging style " It may not , but it sure makes your crap easier for me to debug when it breaks .</tokentext>
<sentencetext>"Forced whitespacing doesn't suit my debugging style"It may not, but it sure makes your crap easier for me to debug when it breaks.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051356</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31052848</id>
	<title>Re:Python is waaaayyy better</title>
	<author>Johnny Loves Linux</author>
	<datestamp>1265563800000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I've never had a problem with python's whitespace parsing, but I read somewhere that python is so superior it has support for all the other schemes to denote blocks. For example, you can use 'begin' and 'end' keywords, you can also use braces {,} as well. Here's an example demonstrating python's superior syntax:</p><p><div class="quote"><p>if foo == 3:<br>
   #begin<br><nobr> <wbr></nobr>....block of code here....<br>
   #end<br>
else:<br>
   #{<br><nobr> <wbr></nobr>....another block of code here....<br>
   #}</p> </div><p> You say you don't like 'len' as a name for a length function, that you would prefer using the name 'length'. Well, python is so superior, that you can fix that problem really fast in your code:</p><p><div class="quote"><p>length = len</p></div><p> From your posting, you've got lots of experience number crunching. Have you taken a look at numpy and scipy? There optimized modules to give python the speed of fortran for doing linear algebra, statistics, etc. Want to do an svd,linear regression, sampling, etc. in python fast and easy? numpy is your best friend.

</p><p> The one big showstopper I have with F# (which might (maybe) actually be an awesome language) is of course that it comes from Microsoft, who has a better proven history of screwing people and locking them into Windows than some Oil companies have of finding oil. On what platforms can I use this F# language? Please, no equivocating. I just want to be able to do: "sudo apt-get install F-sharp".

</p><p> Why should I wrote code in a language that's bound to a platform/OS that's inferior to the one I use on a daily basis from a company who's trying to lock me into their products, when I have free easy access to code from people who don't have as an agenda screwing me over with their licenses, restrictions, treating me like a suspected criminal? If I want a functional programming language, I can run lisp, ocaml, haskell, ML, erlang, none of which restrict me as to which platform or OS I use.</p></div>
	</htmltext>
<tokenext>I 've never had a problem with python 's whitespace parsing , but I read somewhere that python is so superior it has support for all the other schemes to denote blocks .
For example , you can use 'begin ' and 'end ' keywords , you can also use braces { , } as well .
Here 's an example demonstrating python 's superior syntax : if foo = = 3 : # begin ....block of code here... . # end else : # { ....another block of code here... . # } You say you do n't like 'len ' as a name for a length function , that you would prefer using the name 'length' .
Well , python is so superior , that you can fix that problem really fast in your code : length = len From your posting , you 've got lots of experience number crunching .
Have you taken a look at numpy and scipy ?
There optimized modules to give python the speed of fortran for doing linear algebra , statistics , etc .
Want to do an svd,linear regression , sampling , etc .
in python fast and easy ?
numpy is your best friend .
The one big showstopper I have with F # ( which might ( maybe ) actually be an awesome language ) is of course that it comes from Microsoft , who has a better proven history of screwing people and locking them into Windows than some Oil companies have of finding oil .
On what platforms can I use this F # language ?
Please , no equivocating .
I just want to be able to do : " sudo apt-get install F-sharp " .
Why should I wrote code in a language that 's bound to a platform/OS that 's inferior to the one I use on a daily basis from a company who 's trying to lock me into their products , when I have free easy access to code from people who do n't have as an agenda screwing me over with their licenses , restrictions , treating me like a suspected criminal ?
If I want a functional programming language , I can run lisp , ocaml , haskell , ML , erlang , none of which restrict me as to which platform or OS I use .</tokentext>
<sentencetext>I've never had a problem with python's whitespace parsing, but I read somewhere that python is so superior it has support for all the other schemes to denote blocks.
For example, you can use 'begin' and 'end' keywords, you can also use braces {,} as well.
Here's an example demonstrating python's superior syntax:if foo == 3:
   #begin ....block of code here....
   #end
else:
   #{ ....another block of code here....
   #}  You say you don't like 'len' as a name for a length function, that you would prefer using the name 'length'.
Well, python is so superior, that you can fix that problem really fast in your code:length = len From your posting, you've got lots of experience number crunching.
Have you taken a look at numpy and scipy?
There optimized modules to give python the speed of fortran for doing linear algebra, statistics, etc.
Want to do an svd,linear regression, sampling, etc.
in python fast and easy?
numpy is your best friend.
The one big showstopper I have with F# (which might (maybe) actually be an awesome language) is of course that it comes from Microsoft, who has a better proven history of screwing people and locking them into Windows than some Oil companies have of finding oil.
On what platforms can I use this F# language?
Please, no equivocating.
I just want to be able to do: "sudo apt-get install F-sharp".
Why should I wrote code in a language that's bound to a platform/OS that's inferior to the one I use on a daily basis from a company who's trying to lock me into their products, when I have free easy access to code from people who don't have as an agenda screwing me over with their licenses, restrictions, treating me like a suspected criminal?
If I want a functional programming language, I can run lisp, ocaml, haskell, ML, erlang, none of which restrict me as to which platform or OS I use.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051356</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051256</id>
	<title>Re:.NET Framework</title>
	<author>Anonymous</author>
	<datestamp>1265539620000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p><div class="quote"><p>Yeah I know patents bla bla mono bla bla Novell bla bla Miguel bla bla.</p></div><p>"Concern" for americans only. We here in Europe don't give a flying fuck about US software "patents"<nobr> <wbr></nobr>:-)</p></div>
	</htmltext>
<tokenext>Yeah I know patents bla bla mono bla bla Novell bla bla Miguel bla bla .
" Concern " for americans only .
We here in Europe do n't give a flying fuck about US software " patents " : - )</tokentext>
<sentencetext>Yeah I know patents bla bla mono bla bla Novell bla bla Miguel bla bla.
"Concern" for americans only.
We here in Europe don't give a flying fuck about US software "patents" :-)
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051062</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051576</id>
	<title>Marketing? What the?</title>
	<author>Puff\_Of\_Hot\_Air</author>
	<datestamp>1265545140000</datestamp>
	<modclass>Informativ</modclass>
	<modscore>3</modscore>
	<htmltext>I understand that it is popular to bash anything that burst forth from the loins of Microsoft, but c'mon! This is Don, The Don, this is one hard-core damned brilliant programming dude (for want of a better term). He was single handedly responsible for generics in c# (something I am greatly thankful for in my day to day work) F# is his baby; the guy is passionate about the idea of a real world practical functional language. Sometimes people use emotive language when they are talking about things that they have devoted themselves to for years. Especially when they believe that it could bring functional programming into the mainstream.

I have used F#, and personally really enjoy coding with it (and especially the different way in which solving problems in this manner makes you think). Might be a long time before it is excepted into production code though...</htmltext>
<tokenext>I understand that it is popular to bash anything that burst forth from the loins of Microsoft , but c'mon !
This is Don , The Don , this is one hard-core damned brilliant programming dude ( for want of a better term ) .
He was single handedly responsible for generics in c # ( something I am greatly thankful for in my day to day work ) F # is his baby ; the guy is passionate about the idea of a real world practical functional language .
Sometimes people use emotive language when they are talking about things that they have devoted themselves to for years .
Especially when they believe that it could bring functional programming into the mainstream .
I have used F # , and personally really enjoy coding with it ( and especially the different way in which solving problems in this manner makes you think ) .
Might be a long time before it is excepted into production code though.. .</tokentext>
<sentencetext>I understand that it is popular to bash anything that burst forth from the loins of Microsoft, but c'mon!
This is Don, The Don, this is one hard-core damned brilliant programming dude (for want of a better term).
He was single handedly responsible for generics in c# (something I am greatly thankful for in my day to day work) F# is his baby; the guy is passionate about the idea of a real world practical functional language.
Sometimes people use emotive language when they are talking about things that they have devoted themselves to for years.
Especially when they believe that it could bring functional programming into the mainstream.
I have used F#, and personally really enjoy coding with it (and especially the different way in which solving problems in this manner makes you think).
Might be a long time before it is excepted into production code though...</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050984</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31054622</id>
	<title>Re:Looks interesting as replacement for Python</title>
	<author>Anonymous</author>
	<datestamp>1265535960000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Here's the corresponding F# one liner, same length and simplicity as the Python one liner:</p><p>let rec factorial n = if n=0 then 1 else n*factorial (n-1)</p><p>Here's another F# one liner factorial, without recursion:</p><p>let factorial n = Seq.reduce (*) [1..n]</p></htmltext>
<tokenext>Here 's the corresponding F # one liner , same length and simplicity as the Python one liner : let rec factorial n = if n = 0 then 1 else n * factorial ( n-1 ) Here 's another F # one liner factorial , without recursion : let factorial n = Seq.reduce ( * ) [ 1..n ]</tokentext>
<sentencetext>Here's the corresponding F# one liner, same length and simplicity as the Python one liner:let rec factorial n = if n=0 then 1 else n*factorial (n-1)Here's another F# one liner factorial, without recursion:let factorial n = Seq.reduce (*) [1..n]</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051780</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31053850</id>
	<title>Re:Looks interesting as replacement for Python</title>
	<author>Anonymous</author>
	<datestamp>1265573040000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>This is probably an attempt to gently introduce 'match' which is a bit addictive. F# supports the 'if' syntax you prefer.</p><p>In my experience, the match syntax is very powerful for composing 'dialog' between components. Consider the simplest case of F#'s option:</p><p>type Option =<br>
&nbsp; &nbsp; &nbsp; &nbsp; | None<br>
&nbsp; &nbsp; &nbsp; &nbsp; | Some of 'a</p><p>You have a function that can fail, but you don't want to throw (to avoid debug headaches perhaps). You return an option value and:</p><p>
&nbsp; &nbsp; &nbsp; &nbsp; match value with<br>
&nbsp; &nbsp; &nbsp; &nbsp; | None -&gt;<nobr> <wbr></nobr>// Handle failure case<br>
&nbsp; &nbsp; &nbsp; &nbsp; | Some x -&gt;<nobr> <wbr></nobr>// x is the value you want</p><p>And that is only the beginning.</p><p>Just because the syntax is not what you are used to, it doesn't make it poor. If you have the time, learn it and see if it is valuable.</p></htmltext>
<tokenext>This is probably an attempt to gently introduce 'match ' which is a bit addictive .
F # supports the 'if ' syntax you prefer.In my experience , the match syntax is very powerful for composing 'dialog ' between components .
Consider the simplest case of F # 's option : type Option =         | None         | Some of 'aYou have a function that can fail , but you do n't want to throw ( to avoid debug headaches perhaps ) .
You return an option value and :         match value with         | None - &gt; // Handle failure case         | Some x - &gt; // x is the value you wantAnd that is only the beginning.Just because the syntax is not what you are used to , it does n't make it poor .
If you have the time , learn it and see if it is valuable .</tokentext>
<sentencetext>This is probably an attempt to gently introduce 'match' which is a bit addictive.
F# supports the 'if' syntax you prefer.In my experience, the match syntax is very powerful for composing 'dialog' between components.
Consider the simplest case of F#'s option:type Option =
        | None
        | Some of 'aYou have a function that can fail, but you don't want to throw (to avoid debug headaches perhaps).
You return an option value and:
        match value with
        | None -&gt; // Handle failure case
        | Some x -&gt; // x is the value you wantAnd that is only the beginning.Just because the syntax is not what you are used to, it doesn't make it poor.
If you have the time, learn it and see if it is valuable.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051780</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050976</id>
	<title>functional programming is for autists</title>
	<author>Anonymous</author>
	<datestamp>1265576040000</datestamp>
	<modclass>Troll</modclass>
	<modscore>-1</modscore>
	<htmltext><p>insane in the membrane<nobr> <wbr></nobr>:(</p></htmltext>
<tokenext>insane in the membrane : (</tokentext>
<sentencetext>insane in the membrane :(</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051122</id>
	<title>F# is awesome</title>
	<author>Anonymous</author>
	<datestamp>1265536320000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>1</modscore>
	<htmltext><p>As a longtime programmer in languages such as C++, Java, C# etc, and having explored many other dynamic and functional languages such as Perl, Python, Ruby, Haskell, and Lisp, I can honestly say that F# is now hands down my favorite language.  There are a few reasons:</p><p>- it's like the best parts of all the paradigms rolled into one.  Statically typed, but with automatic type inference to do most of the work for you.  Fantastic generics - every function is generic without any of the scary syntax or mental overhead.  First class functions, closures, all that good functional stuff.  All the same objected oriented features you'd have in C#.  All the garbage collection etc of the<nobr> <wbr></nobr>.NET platform.  You can do things in almost any style you want and it never feels like you have to fight the language.</p><p>Of course, pick and choose your language, and you can find many of those features elsewhere.  But here's the best part:</p><p>- it runs on<nobr> <wbr></nobr>.NET.  You can use all of the<nobr> <wbr></nobr>.NET libraries, no need to hunt for and integrate third party libraries that are half implemented because of your wacky obscure language choice.</p><p>- you can sell it to your boss.  Supported as an official MS product and included in Visual Studio 2010.  Integrates flawlessly with C#.  Has a great IDE already.  Draw your WPF GUI in Expression Web if you feel like it and write the backend in F#.</p><p>Honestly I never want to go back.  It's like that Paul Graham essay where he talks about how Lisp is so productive that his company killed the competition.  Now I feel like every line of C#/C++ I write is a waste of my time.</p></htmltext>
<tokenext>As a longtime programmer in languages such as C + + , Java , C # etc , and having explored many other dynamic and functional languages such as Perl , Python , Ruby , Haskell , and Lisp , I can honestly say that F # is now hands down my favorite language .
There are a few reasons : - it 's like the best parts of all the paradigms rolled into one .
Statically typed , but with automatic type inference to do most of the work for you .
Fantastic generics - every function is generic without any of the scary syntax or mental overhead .
First class functions , closures , all that good functional stuff .
All the same objected oriented features you 'd have in C # .
All the garbage collection etc of the .NET platform .
You can do things in almost any style you want and it never feels like you have to fight the language.Of course , pick and choose your language , and you can find many of those features elsewhere .
But here 's the best part : - it runs on .NET .
You can use all of the .NET libraries , no need to hunt for and integrate third party libraries that are half implemented because of your wacky obscure language choice.- you can sell it to your boss .
Supported as an official MS product and included in Visual Studio 2010 .
Integrates flawlessly with C # .
Has a great IDE already .
Draw your WPF GUI in Expression Web if you feel like it and write the backend in F # .Honestly I never want to go back .
It 's like that Paul Graham essay where he talks about how Lisp is so productive that his company killed the competition .
Now I feel like every line of C # /C + + I write is a waste of my time .</tokentext>
<sentencetext>As a longtime programmer in languages such as C++, Java, C# etc, and having explored many other dynamic and functional languages such as Perl, Python, Ruby, Haskell, and Lisp, I can honestly say that F# is now hands down my favorite language.
There are a few reasons:- it's like the best parts of all the paradigms rolled into one.
Statically typed, but with automatic type inference to do most of the work for you.
Fantastic generics - every function is generic without any of the scary syntax or mental overhead.
First class functions, closures, all that good functional stuff.
All the same objected oriented features you'd have in C#.
All the garbage collection etc of the .NET platform.
You can do things in almost any style you want and it never feels like you have to fight the language.Of course, pick and choose your language, and you can find many of those features elsewhere.
But here's the best part:- it runs on .NET.
You can use all of the .NET libraries, no need to hunt for and integrate third party libraries that are half implemented because of your wacky obscure language choice.- you can sell it to your boss.
Supported as an official MS product and included in Visual Studio 2010.
Integrates flawlessly with C#.
Has a great IDE already.
Draw your WPF GUI in Expression Web if you feel like it and write the backend in F#.Honestly I never want to go back.
It's like that Paul Graham essay where he talks about how Lisp is so productive that his company killed the competition.
Now I feel like every line of C#/C++ I write is a waste of my time.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050952</id>
	<title>Anyone else think is was a .NET Fortran?</title>
	<author>IvyKing</author>
	<datestamp>1265575500000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>Being an old fuddy-duddy, my first thought that Microsoft was doing a dot NET version of Fortran, but... <p>

Obvious retort is why?</p></htmltext>
<tokenext>Being an old fuddy-duddy , my first thought that Microsoft was doing a dot NET version of Fortran , but.. . Obvious retort is why ?</tokentext>
<sentencetext>Being an old fuddy-duddy, my first thought that Microsoft was doing a dot NET version of Fortran, but... 

Obvious retort is why?</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051722</id>
	<title>Re:Looks interesting as replacement for Python</title>
	<author>monoi</author>
	<datestamp>1265547780000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>Or you could, you know, just use perl 5 and have <i>for my $x in ( 2..5 )</i> do exactly what you expect it to.

I quite like Python, but I don't really get why it has displaced perl as the scripting language of choice. It seems to make most simple tasks just slightly harder than they need to be.</htmltext>
<tokenext>Or you could , you know , just use perl 5 and have for my $ x in ( 2..5 ) do exactly what you expect it to .
I quite like Python , but I do n't really get why it has displaced perl as the scripting language of choice .
It seems to make most simple tasks just slightly harder than they need to be .</tokentext>
<sentencetext>Or you could, you know, just use perl 5 and have for my $x in ( 2..5 ) do exactly what you expect it to.
I quite like Python, but I don't really get why it has displaced perl as the scripting language of choice.
It seems to make most simple tasks just slightly harder than they need to be.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051356</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31055634</id>
	<title>Re:Checkbox marketing</title>
	<author>vikstar</author>
	<datestamp>1265542620000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>F# for Scientists<nobr> <wbr></nobr>... F# in the finance industry<nobr> <wbr></nobr>... F#<nobr> <wbr></nobr>... statistical machine learning algorithms<nobr> <wbr></nobr>... solar system simulator</p></div><p>Just use Java with the <a href="http://jscience.org/" title="jscience.org">JScience</a> [jscience.org] package.</p></div>
	</htmltext>
<tokenext>F # for Scientists ... F # in the finance industry ... F # ... statistical machine learning algorithms ... solar system simulatorJust use Java with the JScience [ jscience.org ] package .</tokentext>
<sentencetext>F# for Scientists ... F# in the finance industry ... F# ... statistical machine learning algorithms ... solar system simulatorJust use Java with the JScience [jscience.org] package.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050984</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051114</id>
	<title>F is for FUCK Micro$oft!</title>
	<author>Anonymous</author>
	<datestamp>1265535960000</datestamp>
	<modclass>Troll</modclass>
	<modscore>-1</modscore>
	<htmltext><p><a href="http://www.msversus.org/" title="msversus.org" rel="nofollow">http://www.msversus.org/</a> [msversus.org]</p></htmltext>
<tokenext>http : //www.msversus.org/ [ msversus.org ]</tokentext>
<sentencetext>http://www.msversus.org/ [msversus.org]</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31055534</id>
	<title>1984 reference obligatory?</title>
	<author>Anonymous</author>
	<datestamp>1265541900000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Syme disappeared.</p></htmltext>
<tokenext>Syme disappeared .</tokentext>
<sentencetext>Syme disappeared.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051894</id>
	<title>Re:Checkbox marketing</title>
	<author>Dachannien</author>
	<datestamp>1265551200000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Yes, but does it shift paradigms outside the box?</p></htmltext>
<tokenext>Yes , but does it shift paradigms outside the box ?</tokentext>
<sentencetext>Yes, but does it shift paradigms outside the box?</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050984</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31053676</id>
	<title>My answer could be described as meta</title>
	<author>Anonymous</author>
	<datestamp>1265571120000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Q: What's wrong with C and Python?</p><p>A: They are great programming languages, but it is my observation that using them turns you into the sort of dickhead who believes that their opinions are intrinsically superior.</p></htmltext>
<tokenext>Q : What 's wrong with C and Python ? A : They are great programming languages , but it is my observation that using them turns you into the sort of dickhead who believes that their opinions are intrinsically superior .</tokentext>
<sentencetext>Q: What's wrong with C and Python?A: They are great programming languages, but it is my observation that using them turns you into the sort of dickhead who believes that their opinions are intrinsically superior.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051088</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31055248</id>
	<title>Object oriented and functional cannot be combined</title>
	<author>Frans Faase</author>
	<datestamp>1265540040000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>It is impossible to combine a object oriented language with a functional language. Functional languages are about values. Values are closed. Values are the opposite of objects. Functional languages could only work on closed collections of objects as a whole, because such a collection would behave as an object. Any attempt to combine the two will lead to very strange and counter intuitive semantics where either one of the two has is seriously damaged. Either you get a functional language (working on collections of objects as a whole) or you get a object oriented language with non-functional semantics. Everybody who claims that functional and object oriented can be joined either does not understand what these words mean or have an alternative interprettation of what of either one of the two terms.</p></htmltext>
<tokenext>It is impossible to combine a object oriented language with a functional language .
Functional languages are about values .
Values are closed .
Values are the opposite of objects .
Functional languages could only work on closed collections of objects as a whole , because such a collection would behave as an object .
Any attempt to combine the two will lead to very strange and counter intuitive semantics where either one of the two has is seriously damaged .
Either you get a functional language ( working on collections of objects as a whole ) or you get a object oriented language with non-functional semantics .
Everybody who claims that functional and object oriented can be joined either does not understand what these words mean or have an alternative interprettation of what of either one of the two terms .</tokentext>
<sentencetext>It is impossible to combine a object oriented language with a functional language.
Functional languages are about values.
Values are closed.
Values are the opposite of objects.
Functional languages could only work on closed collections of objects as a whole, because such a collection would behave as an object.
Any attempt to combine the two will lead to very strange and counter intuitive semantics where either one of the two has is seriously damaged.
Either you get a functional language (working on collections of objects as a whole) or you get a object oriented language with non-functional semantics.
Everybody who claims that functional and object oriented can be joined either does not understand what these words mean or have an alternative interprettation of what of either one of the two terms.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051226</id>
	<title>FParsec</title>
	<author>shutdown -p now</author>
	<datestamp>1265539080000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>3</modscore>
	<htmltext><p>There's one particular reason to look at F#, and that's <a href="http://www.quanttec.com/fparsec/" title="quanttec.com">FParsec</a> [quanttec.com]. Parser combinators are just awesome, and don't get me wrong - I like the original Parsec, and Haskell in general! - but its IDE support is minimal, and debugging it is a pain.</p><p>With F#, you get the same awesome tool, but in an environment where you can actually use it for day-to-day jobs - write any parsing code as an F# library using FParsec, and call it from the main body of C#/VB/IronPython code.</p></htmltext>
<tokenext>There 's one particular reason to look at F # , and that 's FParsec [ quanttec.com ] .
Parser combinators are just awesome , and do n't get me wrong - I like the original Parsec , and Haskell in general !
- but its IDE support is minimal , and debugging it is a pain.With F # , you get the same awesome tool , but in an environment where you can actually use it for day-to-day jobs - write any parsing code as an F # library using FParsec , and call it from the main body of C # /VB/IronPython code .</tokentext>
<sentencetext>There's one particular reason to look at F#, and that's FParsec [quanttec.com].
Parser combinators are just awesome, and don't get me wrong - I like the original Parsec, and Haskell in general!
- but its IDE support is minimal, and debugging it is a pain.With F#, you get the same awesome tool, but in an environment where you can actually use it for day-to-day jobs - write any parsing code as an F# library using FParsec, and call it from the main body of C#/VB/IronPython code.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31053312</id>
	<title>Licensing?</title>
	<author>halfdan the black</author>
	<datestamp>1265567880000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>F# really is a nice language, but the last time I looked, the licensing is REALLY SCARY. Its under some sort of Microsoft shared source type license which essentially states that you can not use F# is any type commercial environment, unless you are using Windows. So, you are allowed to look at, and write programs, but you could not distribute them.

<p>

Has this improved any? I really would like to used F# on Linux, but I will not go anywhere near something with licensing like this?</p></htmltext>
<tokenext>F # really is a nice language , but the last time I looked , the licensing is REALLY SCARY .
Its under some sort of Microsoft shared source type license which essentially states that you can not use F # is any type commercial environment , unless you are using Windows .
So , you are allowed to look at , and write programs , but you could not distribute them .
Has this improved any ?
I really would like to used F # on Linux , but I will not go anywhere near something with licensing like this ?</tokentext>
<sentencetext>F# really is a nice language, but the last time I looked, the licensing is REALLY SCARY.
Its under some sort of Microsoft shared source type license which essentially states that you can not use F# is any type commercial environment, unless you are using Windows.
So, you are allowed to look at, and write programs, but you could not distribute them.
Has this improved any?
I really would like to used F# on Linux, but I will not go anywhere near something with licensing like this?</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051760</id>
	<title>Re:Looks interesting as replacement for Python</title>
	<author>chico\_the\_chihuahua</author>
	<datestamp>1265548320000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>As the other posters commented, it's not dynamically typed (but it is very generic), and the #light syntax is indentation sensitive (fortunately, tabs are banned, which was the initial bane of my Haskell writing days).</p><p>But, I do suspect that IronPython is not a featured language of VS2010 for precisely the reason you say. M$ probably want F# to gain some traction before officially adding IronPython to VS (if they ever do, that is). Python does have some great ideas inspired by functional languages, but it's in no way a functional programming language. Python doesn't impose any type constraints, but I think that F# takes the approach that a lot of functionality can be expressed with generics, and others must be strongly typed - but the language tries it's best to infer those types for you, so you can usually rely on this, unless things get ambiguous.</p><p>I really like the pipe operator for making a flow of data more explicit:<br>List.fold reduceFunc (List.map someFunc fooList)<br>vs<br>fooList |&gt; List.map someFunc |&gt; List.fold reduceFunc</p><p>Also, there's some interesting implications about what type information is visible in the first example and second (hint: someFunc and reduceFunc know nothing about the data types in the first example).</p></htmltext>
<tokenext>As the other posters commented , it 's not dynamically typed ( but it is very generic ) , and the # light syntax is indentation sensitive ( fortunately , tabs are banned , which was the initial bane of my Haskell writing days ) .But , I do suspect that IronPython is not a featured language of VS2010 for precisely the reason you say .
M $ probably want F # to gain some traction before officially adding IronPython to VS ( if they ever do , that is ) .
Python does have some great ideas inspired by functional languages , but it 's in no way a functional programming language .
Python does n't impose any type constraints , but I think that F # takes the approach that a lot of functionality can be expressed with generics , and others must be strongly typed - but the language tries it 's best to infer those types for you , so you can usually rely on this , unless things get ambiguous.I really like the pipe operator for making a flow of data more explicit : List.fold reduceFunc ( List.map someFunc fooList ) vsfooList | &gt; List.map someFunc | &gt; List.fold reduceFuncAlso , there 's some interesting implications about what type information is visible in the first example and second ( hint : someFunc and reduceFunc know nothing about the data types in the first example ) .</tokentext>
<sentencetext>As the other posters commented, it's not dynamically typed (but it is very generic), and the #light syntax is indentation sensitive (fortunately, tabs are banned, which was the initial bane of my Haskell writing days).But, I do suspect that IronPython is not a featured language of VS2010 for precisely the reason you say.
M$ probably want F# to gain some traction before officially adding IronPython to VS (if they ever do, that is).
Python does have some great ideas inspired by functional languages, but it's in no way a functional programming language.
Python doesn't impose any type constraints, but I think that F# takes the approach that a lot of functionality can be expressed with generics, and others must be strongly typed - but the language tries it's best to infer those types for you, so you can usually rely on this, unless things get ambiguous.I really like the pipe operator for making a flow of data more explicit:List.fold reduceFunc (List.map someFunc fooList)vsfooList |&gt; List.map someFunc |&gt; List.fold reduceFuncAlso, there's some interesting implications about what type information is visible in the first example and second (hint: someFunc and reduceFunc know nothing about the data types in the first example).</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051356</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31054070</id>
	<title>Re:The optimal blend...</title>
	<author>CodeBuster</author>
	<datestamp>1265574840000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>but I wouldn't write a parser in C# either.</p></div><p>The parser example is commonly mentioned as being both more difficult to implement in OO languages and less intuitive. However, if C# is the language chosen to write the parser then there are several fine examples of <a href="http://en.wikipedia.org/wiki/Recursive\_descent" title="wikipedia.org">recursive descent parsing</a> [wikipedia.org] using the <a href="http://en.wikipedia.org/wiki/Visitor\_pattern" title="wikipedia.org">visitor pattern</a> [wikipedia.org] written in C# (mostly by academics). On the other hand, how often is a fully featured parser (of the type which could supply structured symbolic graphs to a code generator) actually implemented in practice? IMHO, the parser example is most often selected to <a href="http://en.wikipedia.org/wiki/Cherry\_picking" title="wikipedia.org">cherry pick</a> [wikipedia.org] a corner case where functional languages excel without mentioning the tremendous strengths of OO languages for many ordinary programing tasks.</p></div>
	</htmltext>
<tokenext>but I would n't write a parser in C # either.The parser example is commonly mentioned as being both more difficult to implement in OO languages and less intuitive .
However , if C # is the language chosen to write the parser then there are several fine examples of recursive descent parsing [ wikipedia.org ] using the visitor pattern [ wikipedia.org ] written in C # ( mostly by academics ) .
On the other hand , how often is a fully featured parser ( of the type which could supply structured symbolic graphs to a code generator ) actually implemented in practice ?
IMHO , the parser example is most often selected to cherry pick [ wikipedia.org ] a corner case where functional languages excel without mentioning the tremendous strengths of OO languages for many ordinary programing tasks .</tokentext>
<sentencetext>but I wouldn't write a parser in C# either.The parser example is commonly mentioned as being both more difficult to implement in OO languages and less intuitive.
However, if C# is the language chosen to write the parser then there are several fine examples of recursive descent parsing [wikipedia.org] using the visitor pattern [wikipedia.org] written in C# (mostly by academics).
On the other hand, how often is a fully featured parser (of the type which could supply structured symbolic graphs to a code generator) actually implemented in practice?
IMHO, the parser example is most often selected to cherry pick [wikipedia.org] a corner case where functional languages excel without mentioning the tremendous strengths of OO languages for many ordinary programing tasks.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051196</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051670</id>
	<title>Re:.NET Framework</title>
	<author>SparafucileMan</author>
	<datestamp>1265546940000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>That's great and all but<nobr> <wbr></nobr>.NET is a library, not a language. It sounds like the fact that you enjoyed IronPython after coming from a C# background really has nothing to do with Python as much as it does the fact that you already knew the<nobr> <wbr></nobr>.NET library.</p><p>If you don't know<nobr> <wbr></nobr>.NET? Well, thats another library to learn, and is no better or worse than anything else.</p></htmltext>
<tokenext>That 's great and all but .NET is a library , not a language .
It sounds like the fact that you enjoyed IronPython after coming from a C # background really has nothing to do with Python as much as it does the fact that you already knew the .NET library.If you do n't know .NET ?
Well , thats another library to learn , and is no better or worse than anything else .</tokentext>
<sentencetext>That's great and all but .NET is a library, not a language.
It sounds like the fact that you enjoyed IronPython after coming from a C# background really has nothing to do with Python as much as it does the fact that you already knew the .NET library.If you don't know .NET?
Well, thats another library to learn, and is no better or worse than anything else.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051062</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051006</id>
	<title>Re:There going to run out of musical notes soon...</title>
	<author>bipbop</author>
	<datestamp>1265533440000</datestamp>
	<modclass>Informativ</modclass>
	<modscore>3</modscore>
	<htmltext>Now that would be unjust.</htmltext>
<tokenext>Now that would be unjust .</tokentext>
<sentencetext>Now that would be unjust.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050946</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051078</id>
	<title>Syntax parser.</title>
	<author>Ranzear</author>
	<datestamp>1265535180000</datestamp>
	<modclass>Funny</modclass>
	<modscore>2</modscore>
	<htmltext>If someone makes a debugger or syntax checker for it, will it be called 'F#CK'?</htmltext>
<tokenext>If someone makes a debugger or syntax checker for it , will it be called 'F # CK ' ?</tokentext>
<sentencetext>If someone makes a debugger or syntax checker for it, will it be called 'F#CK'?</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051356</id>
	<title>Looks interesting as replacement for Python</title>
	<author>otter42</author>
	<datestamp>1265541360000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>2</modscore>
	<htmltext><p>I'm going to say something anathema to the<nobr> <wbr></nobr>/. crowd, but I'm looking into it with interest for replacing Python. I first teethed on FORTRAN, moved to Matlab 10 years lates, and have been using C extensively for the past 2 years. I'm starting into Python as a quick and dirty replacement for Matlab, and am quickly falling into a love-hate relationship with it.</p><p>The love comes from all the cool things that Python can do, for free. Dynamic typing,<nobr> <wbr></nobr>.append() functionality, etc. It's just awesome.</p><p>The hate comes from the sheer lunacy that is Python syntax. Forced whitespacing doesn't suit my debugging style (why not just have the compiler recognize <i>either</i> whitespace <i>or</i> accolades?); functions names like len() are just, frankly, idiotic (length() is much more readable to beginners, and takes only a few extra milliseconds to type for experienced users); and the way of working with indices is just weird (2:5 means the 2nd, 3rd, and 4th elements, but not the fifth; range(2 5) gives you 2 3 4, but not 5.).</p><p>Python reminds me of many of these incredibly powerful scientific projects that never got used by a non-scientist until it was far too late to make changes. range() is a good example of this, as while it perfectly emulates "for i=2; i &lt; 5; i++", it is NOT what you expect to get when you say, outloud, "I want a range of numbers from 2 to 5". Having contributed to Scilab, I should know as I'm equally guilty of this kind of thing.</p><p>If F# can fill this void, by giving functional programming with functional syntax, I'll probably stop my Python experiments and move directly to F#.</p><p>Although to be honest, I'd love to find a python front end that uses non-insane syntax and then simply precompiles it into python syntax at run-time. Then you don't have the MS, Windows, and<nobr> <wbr></nobr>.Net ickiness.</p><p>P.S. I'm not looking to start a flame war about force whitespacing. There are really good reasons to like it. All my programs have consistent whitespacing, except when I debug (I like to put debug programming all the way against the margin, that way there's no possibility of ever forgetting it in the code)). However, you can't have it both ways on readability <i>vis-&#224;-vis</i> function names and indices.</p></htmltext>
<tokenext>I 'm going to say something anathema to the / .
crowd , but I 'm looking into it with interest for replacing Python .
I first teethed on FORTRAN , moved to Matlab 10 years lates , and have been using C extensively for the past 2 years .
I 'm starting into Python as a quick and dirty replacement for Matlab , and am quickly falling into a love-hate relationship with it.The love comes from all the cool things that Python can do , for free .
Dynamic typing , .append ( ) functionality , etc .
It 's just awesome.The hate comes from the sheer lunacy that is Python syntax .
Forced whitespacing does n't suit my debugging style ( why not just have the compiler recognize either whitespace or accolades ?
) ; functions names like len ( ) are just , frankly , idiotic ( length ( ) is much more readable to beginners , and takes only a few extra milliseconds to type for experienced users ) ; and the way of working with indices is just weird ( 2 : 5 means the 2nd , 3rd , and 4th elements , but not the fifth ; range ( 2 5 ) gives you 2 3 4 , but not 5 .
) .Python reminds me of many of these incredibly powerful scientific projects that never got used by a non-scientist until it was far too late to make changes .
range ( ) is a good example of this , as while it perfectly emulates " for i = 2 ; i If F # can fill this void , by giving functional programming with functional syntax , I 'll probably stop my Python experiments and move directly to F # .Although to be honest , I 'd love to find a python front end that uses non-insane syntax and then simply precompiles it into python syntax at run-time .
Then you do n't have the MS , Windows , and .Net ickiness.P.S .
I 'm not looking to start a flame war about force whitespacing .
There are really good reasons to like it .
All my programs have consistent whitespacing , except when I debug ( I like to put debug programming all the way against the margin , that way there 's no possibility of ever forgetting it in the code ) ) .
However , you ca n't have it both ways on readability vis-   -vis function names and indices .</tokentext>
<sentencetext>I'm going to say something anathema to the /.
crowd, but I'm looking into it with interest for replacing Python.
I first teethed on FORTRAN, moved to Matlab 10 years lates, and have been using C extensively for the past 2 years.
I'm starting into Python as a quick and dirty replacement for Matlab, and am quickly falling into a love-hate relationship with it.The love comes from all the cool things that Python can do, for free.
Dynamic typing, .append() functionality, etc.
It's just awesome.The hate comes from the sheer lunacy that is Python syntax.
Forced whitespacing doesn't suit my debugging style (why not just have the compiler recognize either whitespace or accolades?
); functions names like len() are just, frankly, idiotic (length() is much more readable to beginners, and takes only a few extra milliseconds to type for experienced users); and the way of working with indices is just weird (2:5 means the 2nd, 3rd, and 4th elements, but not the fifth; range(2 5) gives you 2 3 4, but not 5.
).Python reminds me of many of these incredibly powerful scientific projects that never got used by a non-scientist until it was far too late to make changes.
range() is a good example of this, as while it perfectly emulates "for i=2; i If F# can fill this void, by giving functional programming with functional syntax, I'll probably stop my Python experiments and move directly to F#.Although to be honest, I'd love to find a python front end that uses non-insane syntax and then simply precompiles it into python syntax at run-time.
Then you don't have the MS, Windows, and .Net ickiness.P.S.
I'm not looking to start a flame war about force whitespacing.
There are really good reasons to like it.
All my programs have consistent whitespacing, except when I debug (I like to put debug programming all the way against the margin, that way there's no possibility of ever forgetting it in the code)).
However, you can't have it both ways on readability vis-à-vis function names and indices.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31054430</id>
	<title>Re:Anyone else think is was a .NET Fortran?</title>
	<author>Kartoffel</author>
	<datestamp>1265534640000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Me too.  I figured Microsoft simply grafted<nobr> <wbr></nobr>.NET junk on top of FORTRAN.  It's actually a pleasant surprise to find out this F# is actually some kind of functional programming.</p></htmltext>
<tokenext>Me too .
I figured Microsoft simply grafted .NET junk on top of FORTRAN .
It 's actually a pleasant surprise to find out this F # is actually some kind of functional programming .</tokentext>
<sentencetext>Me too.
I figured Microsoft simply grafted .NET junk on top of FORTRAN.
It's actually a pleasant surprise to find out this F# is actually some kind of functional programming.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050952</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31058704</id>
	<title>Re:There going to run out of musical notes soon...</title>
	<author>Anonymous</author>
	<datestamp>1265660640000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>A term I coined when asked about the differences between VB.NET and C#</p></htmltext>
<tokenext>A term I coined when asked about the differences between VB.NET and C #</tokentext>
<sentencetext>A term I coined when asked about the differences between VB.NET and C#</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050946</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051758</id>
	<title>Re:.NET Framework</title>
	<author>fredrik70</author>
	<datestamp>1265548260000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>2</modscore>
	<htmltext><p>If you like ironpython, check out Boo (http://boo.codehaus.org/) statically typed (or dynamic if you like) language which has borrowed most of the best features from from python.</p></htmltext>
<tokenext>If you like ironpython , check out Boo ( http : //boo.codehaus.org/ ) statically typed ( or dynamic if you like ) language which has borrowed most of the best features from from python .</tokentext>
<sentencetext>If you like ironpython, check out Boo (http://boo.codehaus.org/) statically typed (or dynamic if you like) language which has borrowed most of the best features from from python.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051062</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051234</id>
	<title>Re:Anyone else think is was a .NET Fortran?</title>
	<author>Anonymous</author>
	<datestamp>1265539200000</datestamp>
	<modclass>Informativ</modclass>
	<modscore>3</modscore>
	<htmltext><p><div class="quote"><p>Being an old fuddy-duddy, my first thought that Microsoft was doing a dot NET version of Fortran, but...</p><p>Obvious retort is why?</p></div><p>I've no idea why you'd want one, but it <a href="http://www.lahey.com/lf71/lf71.htm" title="lahey.com">exists</a> [lahey.com], nonetheless - made by Fujitsu of all things.</p></div>
	</htmltext>
<tokenext>Being an old fuddy-duddy , my first thought that Microsoft was doing a dot NET version of Fortran , but...Obvious retort is why ? I 've no idea why you 'd want one , but it exists [ lahey.com ] , nonetheless - made by Fujitsu of all things .</tokentext>
<sentencetext>Being an old fuddy-duddy, my first thought that Microsoft was doing a dot NET version of Fortran, but...Obvious retort is why?I've no idea why you'd want one, but it exists [lahey.com], nonetheless - made by Fujitsu of all things.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050952</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050964</id>
	<title>F is for Fun?</title>
	<author>Anonymous</author>
	<datestamp>1265575740000</datestamp>
	<modclass>Funny</modclass>
	<modscore>4</modscore>
	<htmltext><p>Sure, when everything works out. Something tells me F will mean something completely different when youre getting compiler errors or crashes.</p></htmltext>
<tokenext>Sure , when everything works out .
Something tells me F will mean something completely different when youre getting compiler errors or crashes .</tokentext>
<sentencetext>Sure, when everything works out.
Something tells me F will mean something completely different when youre getting compiler errors or crashes.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051934</id>
	<title>Time to change</title>
	<author>thetsguy</author>
	<datestamp>1265551860000</datestamp>
	<modclass>Funny</modclass>
	<modscore>3</modscore>
	<htmltext>WTF#</htmltext>
<tokenext>WTF #</tokentext>
<sentencetext>WTF#</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051274</id>
	<title>reliability</title>
	<author>Anonymous</author>
	<datestamp>1265539800000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>What if you need a complex program that's very reliable?  I know it can be done in C and Python, but usually not without rigorous testing.</htmltext>
<tokenext>What if you need a complex program that 's very reliable ?
I know it can be done in C and Python , but usually not without rigorous testing .</tokentext>
<sentencetext>What if you need a complex program that's very reliable?
I know it can be done in C and Python, but usually not without rigorous testing.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051088</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31053448</id>
	<title>Re:Looks interesting as replacement for Python</title>
	<author>Anonymous</author>
	<datestamp>1265568960000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Taking out line breaks does not a one liner make.  Just because it is syntactically correct, if I ever saw someone around me write that I would have to punch them in the face.</p></htmltext>
<tokenext>Taking out line breaks does not a one liner make .
Just because it is syntactically correct , if I ever saw someone around me write that I would have to punch them in the face .</tokentext>
<sentencetext>Taking out line breaks does not a one liner make.
Just because it is syntactically correct, if I ever saw someone around me write that I would have to punch them in the face.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051780</parent>
</comment>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_11</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31055634
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050984
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_28</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31052008
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051062
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_10</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31054392
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31052848
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051356
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_2</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051514
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051062
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_35</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31053850
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051780
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051356
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_49</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051256
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051062
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_1</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31056276
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051076
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_52</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051176
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050952
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_25</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051274
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051088
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_16</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051670
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051062
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_7</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31054430
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050952
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_9</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051246
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050964
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_0</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051086
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050984
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_51</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31052384
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31052224
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_22</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31052760
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051356
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_47</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051168
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050984
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_50</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051758
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051062
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_41</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051722
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051356
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_15</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31053820
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051356
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_14</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31053290
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051076
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_6</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051760
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051356
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_39</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31055470
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051780
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051356
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_42</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31053482
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051576
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050984
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_5</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31054868
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051780
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051356
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_44</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051350
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051250
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_29</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31052348
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050952
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_20</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31053178
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050964
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_34</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31054220
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31052224
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_13</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31052426
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051780
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051356
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_4</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051916
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051356
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_26</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31058704
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050946
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_31</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051020
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050952
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_33</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31053676
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051088
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_19</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31054622
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051780
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051356
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_32</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31054070
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051196
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051076
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_23</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31053556
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051076
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_18</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31054292
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051780
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051356
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_48</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051006
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050946
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_53</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051234
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050952
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_24</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31052414
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051780
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051356
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_38</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31053394
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051780
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051356
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_43</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051894
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050984
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_17</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051602
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051062
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_45</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31053308
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051356
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_21</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31052620
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31052224
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_8</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051150
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050964
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_12</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31064918
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050952
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_46</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051586
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051356
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_37</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31056934
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051780
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051356
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_40</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31053448
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051780
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051356
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_3</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31066610
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31055248
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_36</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31056696
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31055248
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_27</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31057034
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051780
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051356
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_07_0059233_30</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051952
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051780
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051356
</commentlist>
</thread>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_07_0059233.12</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050962
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_07_0059233.10</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051088
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051274
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31053676
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_07_0059233.6</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051250
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051350
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_07_0059233.16</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051062
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051670
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051758
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051256
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051514
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051602
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31052008
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_07_0059233.14</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050984
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051576
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31053482
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051894
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051168
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051086
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31055634
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_07_0059233.4</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050992
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_07_0059233.7</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051356
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31052848
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31054392
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051780
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31056934
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31053394
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31055470
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31054292
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31053850
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31057034
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31054868
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31053448
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051952
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31054622
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31052414
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31052426
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051916
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051760
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31052760
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051722
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051586
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31053308
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31053820
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_07_0059233.5</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31059414
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_07_0059233.8</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050964
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051150
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051246
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31053178
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_07_0059233.9</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051656
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_07_0059233.20</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051208
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_07_0059233.2</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050946
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31058704
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051006
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_07_0059233.0</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051122
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_07_0059233.21</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31054164
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_07_0059233.19</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051076
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31056276
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31053556
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31053290
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051196
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31054070
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_07_0059233.3</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051226
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_07_0059233.1</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31050952
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31052348
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31054430
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31064918
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051234
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051020
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051176
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_07_0059233.13</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31052224
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31052620
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31052384
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31054220
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_07_0059233.11</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31055248
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31056696
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31066610
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_07_0059233.17</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051934
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_07_0059233.18</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051610
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_07_0059233.15</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_07_0059233.31051078
</commentlist>
</conversation>
