<llama33>
is there anything vaguely similar to an ocaml IDE for windows? something at least with a file editor?
<bluestorm>
hum
<bluestorm>
on windows i used editplus
<bluestorm>
(crimson editor is basically the same)
<bluestorm>
just an editor with syntax highlighting, plus binding to the interpreter/compiler
<llama33>
hmm, will have a look
<bluestorm>
hm
<bluestorm>
you can even use emacs !
trrkkkkk has quit [Read error: 148 (No route to host)]
<lde>
yes, emacs does work on windows! (and few other strange os'es)
<llama33>
i'm scared... why is ocaml so good? like for a language that's innovative and academic looking, it has an unusually good implementation and a lot of libraries...
<bluestorm>
hum
<bluestorm>
i'd like to say that it comes from the huge mathematical background of all ML languages
<llama33>
i'm hoping to use it to write an interpriter for my own language... but having looked further into ocaml, my language seems utterly crap, regardless of how easy it seems to implement with ocaml [vs. C, scheme and smalltalk which were the other languages i was considering]
<lde>
seems that everything different than java looks academic to people nowadays ;-)
<llama33>
hehe
smimou has joined #ocaml
Demitar has joined #ocaml
yondalf has joined #ocaml
llama32 has joined #ocaml
slipstream-- has joined #ocaml
slipstream has quit [Read error: 110 (Connection timed out)]
llama33 has quit [Read error: 110 (Connection timed out)]
<llama32>
how do i represent functions as a type? like type x = function or type x = int -> int?
<pango>
the latter, I think
<pango>
they're strongly typed too :)
<pango>
(s/strongly// ?)
<pango>
some say that "strongly typed" term lacks a clear and universally accepted definition
klapmuetz has joined #ocaml
<llama32>
god damnit, ocaml has put me off my own programming language :(
* llama32
has learnt that goodness can be acheived by means other than simplicity
Leonidas has joined #ocaml
swater has quit [Read error: 60 (Operation timed out)]
<llama32>
layer on the SDL bindings - gives menu, console, collision detection, etc.
<llama32>
im considering writing a game of some variet
<llama32>
"emo hunter" perhaps
<llama32>
*variety
<llama32>
or a post apocalyptic RTS with robots and rapid climate change and makeshift weapons and stuff
<bluestorm>
hum
<bluestorm>
do you _really_ want to code a game ?
khaladan_ has joined #ocaml
bluestorm has quit [Remote closed the connection]
<llama32>
sorta... not more than i'd like to throw poo at the whitehouse though
<llama32>
meh
bluestorm has joined #ocaml
<llama32>
my previous attempts at game programming have been in C and objective C
mikeX has joined #ocaml
<llama32>
i tend to give up at the point where memory leaks become memory explosions that scatter bugs everywhere... but i've never tried in a decent language with garbage collection and exception handling
<pango>
well, you can have memory leaks with garbage collectors too... Not exactly the same kind of leaks, but the net result is about the same ;)
khaladan has quit [Read error: 145 (Connection timed out)]
<llama32>
harder to happen though
rillig has joined #ocaml
<llama32>
you don't have to think "right... now where do i de-allocate this?"
<bluestorm>
hm
<bluestorm>
llama32:
<bluestorm>
if you really want it (i personnaly think more fundamental thinks may be more interesting)
<bluestorm>
i think you should do something like a "robot war" game
<mikeX>
memory leaks with garbage collected languages are trickier I think
<bluestorm>
each player code his bot (in OCaml, of course), then you load them, have them fighting with each other, then show a nice replay and so on
<bluestorm>
it's a funny game, and would allow you to try funny things
<llama32>
it's interesting, but i don't think i could have the motivation to write it - i'd rather make something i can send to my [non-geek :)] friends and they can blast some nazis, laugh at the easter eggs, and worship me for making such a fun game :)
<bluestorm>
hum
<bluestorm>
i'm not sure you should hope to do quickly something that is fun to other peoples ^^
<llama32>
well, i've got a lot of free time :)
<pango>
bluestorm: a realtimebattle client, maybe ? :)
<llama32>
i've done half playable games before... i had an RTS with units, projectiles, a [good] random map generator, and i think maybe some collision detection - but i didn't get it to a playable state - only "move the tank with your keyboard, fire with space. fire twice to suddenly exit - this is a feature, not a bug" :)
<bluestorm>
hm llama32
<bluestorm>
with lot of free time you can do lot of great things
<bluestorm>
- maths
<bluestorm>
- functionnal programmation
<bluestorm>
hum
<bluestorm>
you can learn concurrent programmation, the Event module
<bluestorm>
object oriented programming
<bluestorm>
hum
<llama32>
i have 2 things on my mind right now - interpriter/VM for my own language, and a game... nothing else seems fun atm :)
<bluestorm>
i see lots of things that may be more knowledge-rewarding than a game actually
<llama32>
a game can incorporate a lot of interesting things though
<llama32>
for one i'll be getting familiar with ocaml
<bluestorm>
hum
<llama32>
and maybe i'll develop a prototype of my language for scripting the game
<bluestorm>
i saw lot of peoples who wanted to do huge projects, failed, and had not increased their knowledge so much
<bluestorm>
but maybe you're not one of those ^^
<Smerdyakov>
Game programming is soooooo easy compared to so many other things. :)
<llama32>
each time i've developed [parts of :)] games in the past, i've never gotten to a state where it's worth sharing with other people, but i've generally discovered something interesting about threading or maths or optimization etc.
<Smerdyakov>
Right now I'm writing a compiler from a statically-typed functional language to assembly language, with a machine-checked proof of correctness. This is an example of something much harder. :)
<bluestorm>
Smerdyakov:
<bluestorm>
is it a part of a real project
<bluestorm>
?
<Smerdyakov>
bluestorm, now what does that mean?
<bluestorm>
are you working with other peoples ?
<Smerdyakov>
No.
<bluestorm>
:)
<Smerdyakov>
There aren't many other people in the world who know how to write this kind of thing. ;)
<Smerdyakov>
I don't think there are any others in my area.
<bluestorm>
hm
<bluestorm>
is it a public project ?
<bluestorm>
(hum, open source, and so on :-° )
<llama32>
my interpriter/VM project is a pretty big project i'll probably never end up getting to a useful state - i aim for it to be an application framework, multimedia environment, information & communication hub [myspace-ish + wikipedia-ish + etc. but done as programs rather than HTML + server-side scripts]
<Smerdyakov>
bluestorm, will be
<bluestorm>
haha llama32
<Smerdyakov>
llama32, yup, I worked on a similar thing in high school. I'm not a big fan of interpreters or VMs now.
<llama32>
so i figure writing [most of] the interpriter in a practical, game scripting context would be an interesting and rewarding start
<bluestorm>
if i knew who you are
<bluestorm>
i'd say you're fool
<bluestorm>
maybe you're actually a damn great hacker, so i should not :-°
<llama32>
bluestorm: did i say i wanted to do all of it myself?
<llama32>
i think the fool one's more correct :) but where there's a will there's a way
<bluestorm>
hm
<bluestorm>
[17:05] <llama32> bluestorm: did i say i wanted to do all of it myself?
<Smerdyakov>
llama32, why do you think virtual machines are a good idea?
<bluestorm>
_and_ you think peoples will join you. Double fool :-°
<bluestorm>
Smerdyakov: "managed environment" are sooo hype ^^
<bluestorm>
Smerdyakov: is your project in ML ?
<Smerdyakov>
bluestorm, Coq, of course. :)
<bluestorm>
hm
<llama32>
Smerdyakov: for this project, i want a lot of reflection and portability. at runtime, code will be downloaded and run at runtime
<llama32>
i said at runtime twice, oops
<bluestorm>
can you write a compiler exclusively in coq ?
<Smerdyakov>
bluestorm, yes
<bluestorm>
o_O
<llama32>
coq?
<bluestorm>
wasn't aware of that
<Smerdyakov>
llama32, you don't need to use a VM for dynamic code loading.
<Smerdyakov>
llama32, and "portability" was long ago solved by this miracle called "compilers." :P
<llama32>
Smerdyakov: no - but it is easier and in the self-like environment i'm considering, the only choice that fits properly
<llama32>
well the VM isn't going to be written in assembly :)
<Smerdyakov>
llama32, either you are wrong, or the environment you are thinking about has design flaws.
<bluestorm>
hm Smerdyakov, i don't really like CLI/.NET fan for now, but they may be right when then say a common intermediate language may be good (for language binding ease for example)
<bluestorm>
(do someone know where will be the next, promising new camlp4 version available ?)
Skal has joined #ocaml
<llama32>
Smerdyakov: the emphasis for this is on the data - not the code... i want to have a highly dynamic and living bunch of objects floating around, and the code to work on these objects will constantly be changing [in terms of their machine code equivalents] anyway
klapmuetz has quit [Read error: 113 (No route to host)]
<Smerdyakov>
llama32, I believe that statically-typed languages are the way to go for such things, with strong static guarantees about dynamic interactions.
<llama32>
and it's not like there's anything inherintly performance specific about the kind of applications i'm hoping to run in it - they'll basically be more interactive web pages
<Smerdyakov>
You don't need to trade off between performance and other desirable factors. You get it all with a modern static type system.
<llama32>
you sound like a telemarketer :P
<llama32>
there is no real notion of a type in the system i have in mind
<llama32>
prototype-based OO
<Smerdyakov>
Yup, and that is a flaw in your design.
<llama32>
so typing is of no efficiency bonus if it is used
<bluestorm>
typing brings you reliability
<Smerdyakov>
No, your design is an efficiency flaw if it is used. :P
<llama32>
the design isn't so much for a programming system as for a database system with support for interactivity
<llama32>
and it will be [optionally] statically typed anyway
<Smerdyakov>
That doesn't work.
<Smerdyakov>
People who know nothing about programming language design & implementation always say that they'll add a type system on later as an optional feature.
<Smerdyakov>
That fundamentally won't work.
<Smerdyakov>
(Or won't work well, I should say.)
<llama32>
at least on function boundaries - if my function doesn't accept the argument types you use it for, it will not be called and either another function that works on those types will be found, or an exception will be thrown
<Smerdyakov>
I can point out your big mistake there:
<Smerdyakov>
Subtyping is undecidable for many interesting type systems.
Skal has quit [Remote closed the connection]
<Smerdyakov>
So you can't check proper argument typing at runtime.
<llama32>
explain
<Smerdyakov>
You don't know what it means for subtyping to be undecidable?
<llama32>
no... not by that definition anyway :)
mnemonic has joined #ocaml
mikeX has quit [Read error: 110 (Connection timed out)]
Demitar has quit [Read error: 110 (Connection timed out)]
Skal has joined #ocaml
<Smerdyakov>
By what definition?
<llama32>
"subtyping is undecidable"
Skal has quit [Remote closed the connection]
<Smerdyakov>
Do you know what undecidability is?
<llama32>
probably not properly
<Smerdyakov>
An undecidable problem is one that no program can solve.
<mnemonic>
hi
<llama32>
i still don't get what you mean by subtyping is undecidable... types of some values cannot be determined?
<llama32>
hey mnemonic
jajs has quit [Read error: 60 (Operation timed out)]
ita has joined #ocaml
<Smerdyakov>
llama32, were you suggesting not storing any types at runtime, but rather just checking that untyped values have certain types before allowing them to be passed to functions?
Skal has joined #ocaml
<ita>
hi all
<llama32>
yeah, i think so, though obviously types are stored somewhere at all times
<ita>
does anyone know of an existing xml parser implementation (sax)
<llama32>
but function lookup & dispatch is done on demand - not at compilation-to-bytecode time or anything
<Smerdyakov>
llama32, OK, then instead let's focus on the undecidability of type _checking_ for interesting type systems.
<Smerdyakov>
llama32, the problem in question is this: Given value E and type T, does E have type T?
<Smerdyakov>
llama32, for many interesting type systems, no program can answer such questions all the time.
<Smerdyakov>
llama32, for example, you might want a type of functions that always terminate.
ramkrsna has joined #ocaml
<Smerdyakov>
llama32, if you didn't think of that ahead of time and create a mechanism for termination enforcement, you're out of luck as far as completeness goes.
mnemonic has quit [Read error: 104 (Connection reset by peer)]
<llama32>
well E will either be a primitive, or have an inheritance tree leading back to a primitive... but also a type can be a condition of some sort [eg "integer between 3 and 76"], in which case it will be checked using other means involving running another piece of code to see if it's of that type - though i'm yet to determine how this will work exactly
<llama32>
hmm
khaladan has joined #ocaml
<Smerdyakov>
llama32, not all interesting properties can be checked by programs.
<mellum>
what's the point of having a type "integer between 3 and 76"?
<llama32>
you might have a function for some imaginary storage system "open-file-with-number", with two implementations - one dealing with numbers deemed to be on local storage - say, 0-65535, and one dealing with everything else - just any int... of course this particular example is probably a bit stupid, but it could be useful :)
<mellum>
I don't see why an invariant/assertion wouldn't be much more easy and flexible here.
<mellum>
type systems are hairy, and "could be useful" is probably not a good basis
<bluestorm>
hm
<llama32>
well it's the same as [forget which one exactly, but one of the invariant/assertion group :)] anyway..."this function expects the arguments to be like this: ... if this is not so, use a different function, or throw an exception if this isn't possible"
<bluestorm>
mellum:
<bluestorm>
i think constrained type can be good
<mellum>
llama32: well, if that is all you want, you should probably not describe it as "type system"
<llama32>
but it's part of the type system
khaladan_ has quit [Read error: 145 (Connection timed out)]
<bluestorm>
a large part of the object oriented philosophy is "we let the outside access to what make sense only"
<bluestorm>
constrained type may be seen as a part of this logic, i think
<mellum>
llama32: how is this different adding "assert (...)
<mellum>
llama32: to the top of the function?
<llama32>
mellum: because this happens before the function is executed, giving the dispatcher a chance to find a suitable function
<bluestorm>
mellum: and it would allow some weird compile-time optimisations ^^
<mellum>
bluestorm: not really. range constraints for example hardly ever could be proven at compile time, and would need to be checked all the time at runtime
<llama32>
i think much of what i'm doing is already done by the slate language/vm/environment, but i can't get it to compile
<bluestorm>
hm
<pango>
mellum: correct, it would probably be dynamic checking rather than static typing
<bluestorm>
mellum: i'm only considering this with static typing in mind
<bluestorm>
but you're right, it's not likely to be provable it at compile time
<mellum>
bluestorm: If the compiler refuses to compile code where it can prove range validity, you won't get any real work done.
<mellum>
erm. can -> cannot
<bluestorm>
hum
<bluestorm>
following the OOP metaphor
<mellum>
Look ar Pascal, where the length of a string is part of its type. Looks like a good idea, but after about 30 seconds of trying it in practise, you notice it's a *horrible* idea
<bluestorm>
it would be possible only if you acces those constrained variables with special, constrain-preserving operations
<bluestorm>
hm mellum
<bluestorm>
if the length of a string were a part of a type, length of those strings should not be modifiable
<llama32>
mellum: implementation-wise or coding-wise? D does it, and it is a great deal easier to get things done in your code without having to do it all yourself
<mellum>
bluestorm: name a single operation on integers that preserves range
<bluestorm>
(btw, F# use un-mutable utf8 strings, and i think it's one (maybe the only one) good idea)
<bluestorm>
hm mellum
<bluestorm>
bijections within the range ? :-°
<mellum>
llama32: uhm, what is "it"?
<llama32>
mellum: having length as part of all strings [arrays in general in D]
<mellum>
llama32: part of the *type*. Every language I know provides access to the length of a string.
<mellum>
llama32: so for example you can't pass a string of length 17 to a function expecting a string of length 6.
<llama32>
hang on... what do you mean by part of the type? limiting the string's length to be within a certain range?
<llama32>
ohhhhh
<llama32>
sorry, misunderstood completely :)
<mellum>
And you cannot write functions taking strings of arbitrary length.
<bluestorm>
hum mellum
<mellum>
Which theoretically avoids many possible errors, but is just too annoying to deal with in practise.
<llama32>
it's 4am - no wonder i'm not very quick atm
<bluestorm>
couldn't they extend polymorphism to string length ?
<llama32>
yeah - i can't imagine an equivalent to puts that only accepts strings of a certain size
<llama32>
of a certain range - but not size
<pango>
ranges again
klapmuetz has joined #ocaml
<pango>
actually I've seen a trick to encode ranges... For safe indexes for specific sized arrays
flibby has joined #ocaml
<llama32>
well, i gtg sleep
llama32 has left #ocaml []
<pango>
from what I understand, each array returns two "root" index values, upper and lower allowed indexes... Then there's a internal function returning the "middle" index of two safe indexes
<flibby>
the thirty second llama has left us now :( LETS EAT MARSHMALLOWS
* flibby
may or may not be llama32's alternate personality
<flibby>
but he probably is
<pango>
so to iterate over the array with those, you have to generate all safe indexes recursively... strange stuff
<jigga_what>
but its all compiled into one resulting executeable correct?
<lde>
it's just a code
trrkkkkk has quit [Read error: 148 (No route to host)]
<lde>
you can do anything you want with it
<jigga_what>
so i mean combining a few c++ or w/e code in it wont increase the code size by any major degree?
<lde>
depends on the quality of generated code
<jigga_what>
hmmmm i see
<lde>
it shouldn't
<jigga_what>
prolly shoukd play around with it
_fab has joined #ocaml
Mr_Awesome has joined #ocaml
<jigga_what>
for the most part are widgets backgorunds . shape etc ..........just made with png's
<jigga_what>
for GTK2 ?
<Mr_Awesome>
theyre made with magic
falconair has joined #ocaml
love-pingoo has quit ["Connection reset by pear"]
danly has quit ["Leaving"]
swater has quit ["Quat"]
falconair has quit []
Skal has quit [Excess Flood]
cmeme has quit [Excess Flood]
Skal has joined #ocaml
cmeme has joined #ocaml
klapmuetz has quit ["leaving"]
jajs has joined #ocaml
love-pingoo has joined #ocaml
khaladan_ has joined #ocaml
khaladan has quit [Read error: 145 (Connection timed out)]
falconair has joined #ocaml
sponge45 has joined #ocaml
<ita>
there is no break in while loops ?
<zmdkrbou>
nope (but there are exceptions)
<ita>
ah, si
<zmdkrbou>
eh ouais
<bluestorm>
zmdkrbou:
<bluestorm>
are you working on Funk ?
<zmdkrbou>
mmh, seems like i got pwnd
<zmdkrbou>
s/are/were/, yes
<bluestorm>
is it still developped ?
<zmdkrbou>
not at the moment, all of us are too busy
<bluestorm>
(because it seems the other OS project, Desert Spring Time, died)
<zmdkrbou>
dst never seemed good to me (and it uses some code from funk which sucks ;p)
<bluestorm>
hm
<zmdkrbou>
i'm not sure now that it was a good idea ... but it was fun :)
<bluestorm>
funk ?
<zmdkrbou>
yep
<bluestorm>
hm
<bluestorm>
if you hoped to conquer the world with a ocaml OS :-°
<zmdkrbou>
i mean that ocaml maybe not really suited for this kind of work (ok thinking the other was the strange point from the beginning :p)
<zmdkrbou>
(+way)
<bluestorm>
hum
<bluestorm>
i think ocaml could do interesting things in some port of the OS code
<zmdkrbou>
there a problem with handling low-level concept using ocaml
<zmdkrbou>
+is
<bluestorm>
(for example, FileSystems algorithms look like recursion and complicated-data-structure friendly)
<bluestorm>
but yes, doing so low level must be very difficult
<bluestorm>
and the problem with kernel is the huge no-so-interesting work at the beginning ^^
<zmdkrbou>
it's too bad that one have to use languages like C just because of a minor part of the code (the really low-level part)
<zmdkrbou>
the hard part is mixing C and ocaml, in fact
<love-pingoo>
zmdkrbou++
<pango>
and problem with multithreading I guess
<bluestorm>
let's hope coyotos won't stop too :-°
<zmdkrbou>
bluestorm: mmmh i think coyotos won't even live before it dies :)
<bluestorm>
hey
<bluestorm>
:-°
<bluestorm>
their website use SVG
<bluestorm>
_this_ is serious
<zmdkrbou>
ideas are cool but they seem to change their mind every two months, and it's supposed to be implemented using a language for which there is no compiler yet (i'm not even sure the language has been entirely defined yet)
<bluestorm>
hum
<bluestorm>
house seems funny too
<zmdkrbou>
house seemed impressive to me
<love-pingoo>
coyotos has a svg website, wow
<love-pingoo>
I need to see that
<love-pingoo>
:)
<bluestorm>
zmdkrbou: you're right, bitcc is still moving
<zmdkrbou>
It is far too early to speculate about release dates. << heh :)
<zmdkrbou>
but i won't spit on coyotos, since i agree with the idea that new kernels should be implemented using modern languages ...
<Mr_Awesome>
what are you guys talking about?
<mbishop>
what language does coyotos use?
<mbishop>
I like some of their ideas
<zmdkrbou>
bitcc
<zmdkrbou>
not yet implemented :)
<mbishop>
oh yeah
<mbishop>
that's too much like C if you ask me
<zmdkrbou>
the language looks like lisp and is supposed to handle low-level concept
<zmdkrbou>
and it's supposed to have a syntax that can be customized
<zmdkrbou>
(because lisp syntax heeem ...)
<bluestorm>
hm
<bluestorm>
recently they said lisp/scheme syntax wans't mandatory
<bluestorm>
"executing code from string" is even worse than bytecode
<Mr_Awesome>
so thats an advantage of dynamic languages, you can use the language itself as a scripting language
<ita>
in javascript the function eval() does it (in python: exec())
<Mr_Awesome>
in ruby its eval
<bluestorm>
hm
<mbishop>
how dare you speak bad of lisp :P
<ita>
mbishop: ignorance
<Mr_Awesome>
ita: did i not say it was brilliant in theory?
<mbishop>
I like lisp, it's not that great at everything (only thing I don't like is how specific it is from system to system)
<mbishop>
and there isn't a simpler syntax
<Mr_Awesome>
i just cant deal with ridiculous named functions like mappend, cadr, nconc, etc
<Mr_Awesome>
i really tried hard to like lisp
<Mr_Awesome>
but i just cant ever see myself programming something non-trivial in it
<dan2>
lisp is awful
<lde>
you can't have simpler syntax!
<zmdkrbou>
there is no syntax in lisp
<lde>
well, unless you want to program in lambda calculus
<zmdkrbou>
and that sucks
<Mr_Awesome>
zmdkrbou: yes there is, its just minimal
<zmdkrbou>
that's what i meant and that's what i don't like
<Mr_Awesome>
i dont particularly like it either, but thats not really the worst part
<zmdkrbou>
(i mean one of the things i don't like in lisp, there's more ;p)
<dan2>
I really like python
<Mr_Awesome>
i cant get used s-expressions, at times theyre more logical
<dan2>
I wish it was faster
<dan2>
:)
<Mr_Awesome>
*used to
<ita>
dan2: if you think lisp is awful, have a look at javascript - it is worse but used much more than you can imagine
<Mr_Awesome>
dan2: you think python is slow, try ruby
<dan2>
heh
<dan2>
Mr_Awesome: hahahahhaha
<dan2>
Mr_Awesome: Java sealed it's fate in voip and video over ip
<lde>
try javascript
<lde>
javascript interpreters are slow
<dan2>
Mr_Awesome: it doesn't offer full 32 bit integers to do encoding operations
<Mr_Awesome>
dan2: ... what?
<mbishop>
I heard someone say ruby is gonna use a VM soon
<dan2>
Mr_Awesome: C++ is going to be the de facto language of voip until Java fixes the fact that it's way too slow to handle encoding/decoding operations... and Strings because of U-16
<mbishop>
but I still don't like interpreted languages
<dan2>
mbishop: I wouldn't be surprised
danly has quit ["Leaving"]
<mbishop>
Java? fix? hardly :P
<dan2>
if Java used UTF-8 it might have had a chance
<lde>
dan2: java will be the de facto language of everything because it's java, no matter how hard it is
<ita>
mbishop: you mean language interpreters (scripting languages can be compiled into native code)
<dan2>
lde: there is a major shortage of programmers for voip applications simply because you need to be good at many things
<Mr_Awesome>
dan2: why is this being directed at me?
<dan2>
not sure
<dan2>
:)
<mbishop>
ita: well yes, but I mean interpreted languages as in, languages that don't bother to do bytecode or native
<Mr_Awesome>
i agree with that statement
<lde>
i hate it when someone says 'interpreted language'
<dan2>
Python, Ruby, and Perl have a very good chance of being used for SIP/RTP because all of the libraries are written in C, and these have well defined, decent C interfaces
<lde>
or 'compiled language', for that matter
<lde>
:-)
<ita>
mbishop: meaninless once again
<ita>
lde: same here
<mbishop>
ita: hmm, I know what you are saying, it's up to the implementation as to wether it's interpreted or compiled, but I'm just saying in general
* mbishop
shrugs
<ita>
while at it, python has cpython (interpreter in c) and ironpython (bytecode for .net)
<mbishop>
I was reading about F# earlier
<mbishop>
apparently they use ocaml for the core?
<ita>
something similar
falconair has quit []
<mbishop>
that's something that I hate, like someone was talking about haskell, and was like "how many compilers does ocaml have? 1, haskell has a whole bunch!"...but ocaml's compiler is GOOD, standardized, not just some jobless hippy doing it in their spare time :/
<mbishop>
which is what I kind of like about microsoft's .NET stuff, people are payed to make it good, not just hodge podge whenever they feel like it
<ita>
jobless hippies :-)
<zmdkrbou>
mouahahahahahhahahahah
<mbishop>
ita: it's true :P I like open source, don't get me wrong, but when it comes to a language, I want some good solid backing, not just a bunch of guys with cvs access or something
<ita>
a language or a compiler ?
<mbishop>
both
<zmdkrbou>
mbishop: lots of languages and compilers are developed by researchers
<Mr_Awesome>
would anyone here say ocaml is a variant of lisp?
<mbishop>
Mr_Awesome: no
<zmdkrbou>
Mr_Awesome: er, just no
<ita>
mbishop: admit it, you resent it coz' you cant understand monads ..
<mbishop>
ita: haha, I like haskell, but it's true, I don't really understand monads :P
<ita>
Mr_Awesome: like java is a variant of algol ?
<Mr_Awesome>
ita: thats what i said, but this guy wont listen to me
<ita>
:-)
<Mr_Awesome>
i said like C is a variant of asm
<Mr_Awesome>
but i like yours better
<trrkkkkk>
GHC is developed mostly by people at Microsoft Research.
danly has joined #ocaml
<mbishop>
trrkkkkk: that's true, and it's kind of obvious if you ask me (GHC sure seemed to be the most advanced)
<trrkkkkk>
Not that I care really who writes a compiler, as long as it's correct and it works well.
Skal has quit [Read error: 104 (Connection reset by peer)]
<Mr_Awesome>
mbishop: would you say ocaml and lisp "aren't all that different?"
<bluestorm>
Mr_Awesome:
<bluestorm>
use history
<dan2>
C is the portable assembler
<bluestorm>
Caml is from the ML family
<lde>
not that there's something bad about microsoft. everyone can make bad software sometimes. and when people are wishing to pay serious money for it, you don't say "no no, it's not for sale, it sucks"
<Mr_Awesome>
i know that
<bluestorm>
whereas Lisp isn't
<mbishop>
Mr_Awesome: I'd say the only thing that makes them similar in any way really is the fact they both are usually tied to functional programming
<bluestorm>
this should be clear
<Mr_Awesome>
well you can s/ml/ocaml in all my statements
<Mr_Awesome>
mbishop: thats what i said
<Mr_Awesome>
but he said they are similar in syntax and the way they are set up etc etc
<bluestorm>
:D
<mbishop>
nope
<bluestorm>
Mr_Awesome: he must be drunk, just wait for tomorrow morning
<Mr_Awesome>
no hes totally sober
<Mr_Awesome>
but thanks for assuring me that im not retarded
<dan2>
if Haskell wasn't such a pain in the ass to program in....
<trrkkkkk>
It's not that bad.
danly has quit [Remote closed the connection]
<bluestorm>
do you know MetaOCaml ?
<dan2>
I don't like something that doesn't do what I ask it to do
<dan2>
I have to `seq` bleh
<dan2>
trrkkkkk: since it's mostly developed by Microsoft Research, does that mean it makes code very portable between MS and Linux?
<mbishop>
easiest way now a days to be portable is just port to .NET
<trrkkkkk>
I'm not a big fan of laziness but it's not the biggest problem in the world.
<Mr_Awesome>
if haskell didnt do that whitespace determines structure crap
<bluestorm>
Microsoft Research you linux, dan2 :)
johnnowak has joined #ocaml
<bluestorm>
hum
<bluestorm>
s/you/use/
* ita
wonders what ".<" could mean
johnnowak has quit [Client Quit]
<trrkkkkk>
I don't know what you mean, since Microsoft Research isn't really the same as being in the Office group or anything.
<trrkkkkk>
But GHC works on win32 and posix systems.
johnnowak has joined #ocaml
<zmdkrbou>
ghc is not developed by ms research
<trrkkkkk>
It was more to point out that they have jobs.
<trrkkkkk>
It is developed by employees of Microsoft Research.