dark_light changed the topic of #ocaml to: OCaml 3.09.2 available! Archive of Caml Weekly News: http://sardes.inrialpes.fr/~aschmitt/cwn/ | A free book: http://cristal.inria.fr/~remy/cours/appsem/ | Mailing List: http://caml.inria.fr/bin/wilma/caml-list/ | Cookbook: http://pleac.sourceforge.net/
jigga_what has joined #ocaml
<jigga_what> is there any binding generators for Ocaml ?
<pango_> several, ocamlIDL, SWIG, Forklift... But I have no personal experience with those
<jigga_what> pango_: and what do they actually do create ocaml bindings to those specific libraires ?
love-pingoo has joined #ocaml
danly has joined #ocaml
bluestorm has quit ["Konversation terminated!"]
sponge45 has joined #ocaml
danly has quit [Remote closed the connection]
dark_light has joined #ocaml
swater has quit ["Quat"]
johnnowak has joined #ocaml
khaladan has joined #ocaml
khaladan_ has quit [Read error: 145 (Connection timed out)]
MisterC has joined #ocaml
MisterC has quit [Read error: 104 (Connection reset by peer)]
Skal has quit [Read error: 60 (Operation timed out)]
mbishop has quit [Remote closed the connection]
trrkkkkkk has joined #ocaml
smimou has quit ["bli"]
love-pingoo has quit ["Connection reset by pear"]
trrkkkkk has quit [Read error: 145 (Connection timed out)]
danly has joined #ocaml
johnnowak has quit []
khaladan_ has joined #ocaml
khaladan has quit [Read error: 145 (Connection timed out)]
Smerdyakov has quit [Remote closed the connection]
pebblestone has joined #ocaml
_fab has quit [Read error: 145 (Connection timed out)]
_fab has joined #ocaml
sponge45 has quit ["zzzzzzzzzz"]
falconair has quit []
khaladan has joined #ocaml
khaladan_ has quit [Read error: 145 (Connection timed out)]
dibblego has joined #ocaml
trrkkkkk has joined #ocaml
falconair has joined #ocaml
johnnowak has joined #ocaml
pango has joined #ocaml
pango_ has quit [Remote closed the connection]
johnnowak has left #ocaml []
johnnowak has joined #ocaml
johnnowak has quit [Client Quit]
johnnowak has joined #ocaml
pebblestone has quit [Remote closed the connection]
trrkkkkkk has quit [Read error: 113 (No route to host)]
mbishop has joined #ocaml
sponge45 has joined #ocaml
danly has quit ["Leaving"]
_JusSx_ has joined #ocaml
johnnowak has quit []
buluca has quit [Read error: 104 (Connection reset by peer)]
bluestorm has joined #ocaml
<flux__> jigga_what, I imagine it's still most common to hand-write the bindings
<flux__> jigga_what, which is: write a c-file that wraps c-constructs into ocaml ones, plus write a simple interface in ocaml
<jigga_what> flux__: heh
<jigga_what> how aout for c++
<jigga_what> ;)
<flux__> well, same
<flux__> except extern "C" the stuff
Foxyloxy has quit [Read error: 60 (Operation timed out)]
<jigga_what> i really wish ocaml had a library for qt stuff
<flux__> however if the library is large enough, those binding generators maybe are worth inspecting
<flux__> or maybe a partial
<flux__> binding is sufficient for one's needs
<jigga_what> welll
<jigga_what> i just want a qt binding
<jigga_what> for widget stuff
<flux__> well, for a new-comer it might be too big of a task to write..
<jigga_what> << is not all that new
<jigga_what> but
<jigga_what> hmmmm
<flux__> oh
<flux__> apparently the matter has been discussed somewhat in the net
<jigga_what> well i dunno
<jigga_what> GTK is not exactly my friend though
<jigga_what> flux__: i dont think a binding generator would do much good for qt
<flux__> I suppose the QT preprocessor changes things a bit
<flux__> but swig supports for example ocaml-code inheriting qt-classes
<flux__> plus it comes with a camlp4 language extension that makes it more convenient to work with the wrappers
<flux__> I haven't used it, though, only read the documentation
<jigga_what> i seeee
<jigga_what> << hates gui programming
<jigga_what> allll the toolkits suck
<flux__> there is this, but I imagine this is way outdated: https://savannah.nongnu.org/projects/kamel/
<flux__> plus, project memberlist: 1 members
<flux__> hmm
<flux__> right, the kamel-user-archive for this month contains only spam
<flux__> as is the devel-list
<flux__> so, I suppose it's dead
<jigga_what> blllah
<flux__> so using gtk is not an option?
<jigga_what> welo
<jigga_what> well
<flux__> I believe the gtk-bindings are of high quality
<jigga_what> most likely my onle ;)
<jigga_what> im a kde lover
<flux__> put a gtk-qt-skin and see no difference :)
<flux__> (I don't know how good it is)
<bluestorm> hum
<bluestorm> about Qt
<flux__> btw, do you know how one widens the Qt scrollbar?
<jigga_what> hmmmm
<jigga_what> widens ?
<bluestorm> i think there must be a way to re-use the large Python binding work
<flux__> it's just that recently I set up a cashing system for a computer club with a touch screen, but the scrollbars were too narrow for fingers
<bluestorm> the developper created a whole binding engine that might be adaptable to ocaml
<flux__> but it turns out gtk2 allows the width of scrollbars to be defined in a configuration file
<jigga_what> the gtk-qt is ok i use it but its certainly not something you would want to call stable
<bluestorm> or it may be possible to use Pyqt + Pycaml
<flux__> but if I'm to switch to opera (an option), I would want to make the scrollbars as wide..
<jigga_what> hmmmm
<flux__> bluestorm, well, there is python4ocaml or something, but I suppose it'd be a pain..
<flux__> perl-bindings for qt + perl4ocaml might even be better.
<bluestorm> hm
<bluestorm> to the python binding
<jigga_what> flux__: lol
<bluestorm> the developper created a engine
<bluestorm> to wrap C++ -> python
<jigga_what> how about ocaml +lua + lua_wt
<jigga_what> naw even better
<bluestorm> i thought it would be possible to change it a little to get C++ -> ocaml
<flux__> bluestorm, well, python isn't typed, so it might be a bigger problem to do C++ -> ocaml
<bluestorm> hum
<bluestorm> you're right
<jigga_what> ocaml + python - pyperl + perlua + lua_qt
<bluestorm> but it seems me that the Qt API are mainly classes
<jigga_what> ^^ theres the way to gooo
<bluestorm> and i think the information python needs from the C++ Api to build pytonish classes
<bluestorm> are kinda similar to types informations
<jigga_what> i just gave you guys the perfect solution
<jigga_what> if ocaml had a qt binding i would be set :P
<jigga_what> heh
<jigga_what> i will just use GTK
<jigga_what> and use a theme engine
<jigga_what> oooo sweet some really nice looking themes
* jigga_what likes gtk now
<bluestorm> hm
<bluestorm> actually i think the important differences between qt and gtk aren't exactly themes ^^
<jigga_what> bluestorm: lol
<jigga_what> true
<jigga_what> bluestorm: i get caught up in themes :( lol
ikaros has quit [Read error: 60 (Operation timed out)]
dark_light has quit [Remote closed the connection]
sponge45 has quit ["zzzzzzzzzz"]
ikaros has joined #ocaml
llama33 has joined #ocaml
swater has joined #ocaml
<llama33> does ocaml have things like scheme's list?, number?, etc.?
<pango> no, it's statically typed, so you don't need those predicates
<llama33> but am i right that i can make a type saying "it's either an integer, a string, or a list"?
<llama33> in which case - can i at runtime ask which of the three it actually is?
<pango> yes, with a sum type... But then, values have that sum type type, not one of integer, string or list
<llama33> but... how do i know which it is?
<pango> type 'a int_or_string_or_list = Int of int | String of string | List of 'a list
<llama33> or am i required to do that by other means?
falconair has quit []
<pango> [...] match x with
<pango> | Int i -> (* do something with i *)
<pango> | Some s -> (* do something with s *)
<llama33> i see... sorta...
<pango> | List l -> (* do something with l *)
<pango> s/Some/String/
<llama33> i gotta get more used to ocaml :)
<pango> you use pattern matching on the constructors of the sum type
trrkkkkkk has joined #ocaml
<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)]
<bluestorm> hm
<bluestorm> do you know about ocamlp3l ?
<bluestorm> the membres list sounds like... interesting ^^
<bluestorm> and the topic too
jajs has joined #ocaml
<yondalf> ocamlp3l seems to have not been developed for quite some time according to the cvs web interface
<bluestorm> hum
<bluestorm> yondalf:
<bluestorm> i found it in the "newst update" page of the hump
<yondalf> bluestorm: okay i'll take a look
<bluestorm> hmmm
<bluestorm> jigga_what:
<bluestorm> o_O
yondalf_ has joined #ocaml
<llama32> is it possible to do something like the following?: type x = y list;; type y = X of x | Int of int;;
<pango> simultaneous declarations: type x = y list and y = X of x | Int of int
<llama32> ah, thanks
<llama32> hmm, i knew you could use and, but i thought it was just for clarity & brevity, not actually for a use
<pango> same as functions, with the difference that type declarations are automatically recursive (no need for "rec" keyword)
<bluestorm> hm
<bluestorm> it's seems me that in a "let .. = ... and .. = ... in" clause, the order of evaluation is'n specified
<bluestorm> (i'm not really sure of that, but i personally try not to do things like let x = read_int() and y = read_int() in ...)
<pango> not only that, but some definitions may become monomorphic, so it's not strictly equivalent
<bluestorm> hm
<bluestorm> i don't really see in wich case this can happen ^^
<pango> let rec f x = x and y = f true, f 3
<bluestorm> hm
<bluestorm> but
<bluestorm> clever :p
<bluestorm> type is globally inferred
<yondalf_> # let rec f x = x and y = f true;;
<yondalf_> This kind of expression is not allowed as right-hand side of `let rec'
Leonidas has quit ["An ideal world is left as an exercise to the reader"]
<pango> I remember someone looking for help here, that wrote his whole program as simultaneous declarations, and having monomorphism problems
<pango> # let rec f x = x and y = (f true, f 3) ;;
<pango> This expression has type int but is here used with type bool
<pango> (with "3" underlined)
<pango> yondalf_: but your variant is interesting ;)
<yondalf_> i think you're supposed to type y () = f true;; ?
yondalf has quit [Connection timed out]
<pango> I avoid simultaneous declarations unless strictly necessary... it often gets more tricky than what it's worth ;)
Skal has joined #ocaml
love-pingoo has joined #ocaml
khaladan_ has joined #ocaml
khaladan has quit [Read error: 145 (Connection timed out)]
swater has joined #ocaml
khaladan has joined #ocaml
pebblestone has joined #ocaml
<pebblestone> hi, I found two caml-mode for emacs, one is called tuareg mode, one is from Didier Remy. which one should I use?
<pebblestone> they seem to be different on identation.
Skal has quit [Read error: 54 (Connection reset by peer)]
<love-pingoo> pebblestone: i'd say tuareg is better, more widespread at least
<pebblestone> i see, thanks
<pango> moreover, I guess the indentation of each is customizable ;)
khaladan_ has quit [Read error: 145 (Connection timed out)]
<pebblestone> yes, they're customizable.
yondalf has joined #ocaml
<pebblestone> I tried ocamldebug, but it said "Symbol value as variable is void: caml-mode-map." what's wrong?
trrkkkkk has joined #ocaml
<pebblestone> http://paste.lisp.org/display/29734 , help pls.
yondalf_ has quit [Connection timed out]
yondalf has quit ["leaving"]
<pango> append-tuareg.el here uses (autoload 'camldebug "camldebug-tuareg" "Run the Caml debugger" t), not "camldebug", could that be the problem ?
Smerdyakov has joined #ocaml
trrkkkkkk has quit [Read error: 145 (Connection timed out)]
ziggurat has joined #ocaml
<pebblestone> pango: no, the file is camldebug.el
<pebblestone> btw, I'm using Aquamacs, is there anybody facing the same problem with me?
<pebblestone> ah... i used Remy's caml lib before. so I should change caml-mode-map to tuareg-mode-map. ;-)
pebblestone has quit [Remote closed the connection]
buluca has joined #ocaml
ziggurat has quit ["Leaving"]
_fab has quit [Remote closed the connection]
llama32 has quit [Read error: 110 (Connection timed out)]
llama32 has joined #ocaml
<llama32> :o screw interpriters, i think i'd rather play with mlgame!
<bluestorm> mlgame ?
<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.
<bluestorm> llama32:
<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
<flibby> goodnight
<flibby> WOOOP WOOP WOOP
<flibby> splat!
<flibby> wow, i'm insane...
flibby has left #ocaml []
khaladan_ has joined #ocaml
khaladan has quit [Read error: 145 (Connection timed out)]
_JusSx_ has quit [Client Quit]
danly has joined #ocaml
danly has quit ["Leaving"]
danly has joined #ocaml
khaladan has joined #ocaml
TaXules has quit [Remote closed the connection]
khaladan_ has quit [Read error: 145 (Connection timed out)]
TaXules has joined #ocaml
Smerdyakov has quit ["Leaving"]
<jigga_what> what exactly is SWIG ?
<jigga_what> i mean when you use it does it compile in with your application
<jigga_what> or some external shared library or something
trrkkkkkk has joined #ocaml
<lde> no, it just generates code
<jigga_what> lde: could you expalin a little more ?
<lde> it generates code
<ita> jigga_what: http://www.swig.org/Doc1.1/HTML/Introduction.html#n1 <- read this first
<ita> (linked from the wikipedia page=
<lde> what don't you understand about it?
<jigga_what> it generates ocaml code correcT?
<lde> possibly ocaml and c
<lde> using some high level description
<lde> i don't know, never used it
<jigga_what> i seee
<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
<mbishop> it should be :P
<dan2> it still makes a lot of sense to implement kernels in C
<dan2> C was designed for creating operating systems
<dan2> I don't see another language other than C++, or D that would make much sense
jajs has quit [zelazny.freenode.net irc.freenode.net]
Skal has quit [zelazny.freenode.net irc.freenode.net]
flux__ has quit [zelazny.freenode.net irc.freenode.net]
ulfdoz has quit [zelazny.freenode.net irc.freenode.net]
ikaros has quit [zelazny.freenode.net irc.freenode.net]
dibblego has quit [zelazny.freenode.net irc.freenode.net]
haelix has quit [zelazny.freenode.net irc.freenode.net]
gunark has quit [zelazny.freenode.net irc.freenode.net]
pingu has quit [zelazny.freenode.net irc.freenode.net]
dan2 has quit [zelazny.freenode.net irc.freenode.net]
bebui has quit [zelazny.freenode.net irc.freenode.net]
zmdkrbou has quit [zelazny.freenode.net irc.freenode.net]
Norgg has quit [zelazny.freenode.net irc.freenode.net]
shawn__ has quit [zelazny.freenode.net irc.freenode.net]
bzzbzz has quit [zelazny.freenode.net irc.freenode.net]
khaladan_ has quit [zelazny.freenode.net irc.freenode.net]
love-pingoo has quit [zelazny.freenode.net irc.freenode.net]
cmeme has quit [zelazny.freenode.net irc.freenode.net]
TaXules has quit [zelazny.freenode.net irc.freenode.net]
ramkrsna has quit [zelazny.freenode.net irc.freenode.net]
buluca has quit [zelazny.freenode.net irc.freenode.net]
mattam has quit [zelazny.freenode.net irc.freenode.net]
pattern has quit [zelazny.freenode.net irc.freenode.net]
holdenk has quit [zelazny.freenode.net irc.freenode.net]
sponge45 has quit [zelazny.freenode.net irc.freenode.net]
Mr_Awesome has quit [zelazny.freenode.net irc.freenode.net]
trrkkkkkk has quit [zelazny.freenode.net irc.freenode.net]
ita has quit [zelazny.freenode.net irc.freenode.net]
slipstream-- has quit [zelazny.freenode.net irc.freenode.net]
triple_ has quit [zelazny.freenode.net irc.freenode.net]
jigga_what has quit [zelazny.freenode.net irc.freenode.net]
Ugarte has quit [zelazny.freenode.net irc.freenode.net]
seafood_ has quit [zelazny.freenode.net irc.freenode.net]
tsuyoshi has quit [zelazny.freenode.net irc.freenode.net]
ozzloy has quit [zelazny.freenode.net irc.freenode.net]
Shimei has quit [zelazny.freenode.net irc.freenode.net]
gim has quit [zelazny.freenode.net irc.freenode.net]
Amorphous has quit [zelazny.freenode.net irc.freenode.net]
_fab has quit [zelazny.freenode.net irc.freenode.net]
bluestorm has quit [zelazny.freenode.net irc.freenode.net]
fremo has quit [zelazny.freenode.net irc.freenode.net]
lde has quit [zelazny.freenode.net irc.freenode.net]
mellum has quit [zelazny.freenode.net irc.freenode.net]
l_a_m has quit [zelazny.freenode.net irc.freenode.net]
Hadaka has quit [zelazny.freenode.net irc.freenode.net]
zamez has quit [zelazny.freenode.net irc.freenode.net]
sponge45 has joined #ocaml
khaladan_ has joined #ocaml
love-pingoo has joined #ocaml
jajs has joined #ocaml
cmeme has joined #ocaml
Skal has joined #ocaml
Mr_Awesome has joined #ocaml
_fab has joined #ocaml
trrkkkkkk has joined #ocaml
TaXules has joined #ocaml
ramkrsna has joined #ocaml
ita has joined #ocaml
bluestorm has joined #ocaml
buluca has joined #ocaml
slipstream-- has joined #ocaml
ikaros has joined #ocaml
dibblego has joined #ocaml
jigga_what has joined #ocaml
dan2 has joined #ocaml
triple_ has joined #ocaml
ulfdoz has joined #ocaml
Ugarte has joined #ocaml
flux__ has joined #ocaml
bebui has joined #ocaml
zmdkrbou has joined #ocaml
Norgg has joined #ocaml
haelix has joined #ocaml
bzzbzz has joined #ocaml
pingu has joined #ocaml
shawn__ has joined #ocaml
gunark has joined #ocaml
mattam has joined #ocaml
pattern has joined #ocaml
holdenk has joined #ocaml
Shimei has joined #ocaml
Amorphous has joined #ocaml
gim has joined #ocaml
ozzloy has joined #ocaml
seafood_ has joined #ocaml
tsuyoshi has joined #ocaml
Hadaka has joined #ocaml
fremo has joined #ocaml
l_a_m has joined #ocaml
zamez has joined #ocaml
lde has joined #ocaml
mellum has joined #ocaml
<bluestorm> there is not a lot of low-level, formal language
<bluestorm> is it ?
* zmdkrbou doesn't know about such a language
<dan2> Ada is pretty good for writing kernels
<dan2> it offers all the constructs necessary, and the memory access
<bluestorm> hum, i heard about C--, but it doesn't seems to do the same thing
<dan2> but everybody hates programming in Ada
<dan2> it's a got a type system as strong as ocaml if not stronger
trrkkkkk has joined #ocaml
danly has joined #ocaml
<mbishop> yeah but it doesn't have type inferrence
<mbishop> and code always comes out twice as many lines as another language
jajs has quit [Remote closed the connection]
<zmdkrbou> and there's not garbage collection
* mbishop nods
<mbishop> I hate doing manual memory management
<Mr_Awesome> i LOVE it
<ita> Mr_Awesome: nothing better to do ?
<bluestorm> hum
<bluestorm> i'm afraid manual memory management may be necessary to write a kernel ^^
<mbishop> probably, but I wasn't really talking about that heh
<mbishop> just stating an opinion :P
<mbishop> although I'm sure some genius could come up with a good algorithm that didn't cause pauses and stuff, and the kernel could have it's own GC
rillig has quit ["exit(EXIT_SUCCESS)"]
<bluestorm> hm
<Mr_Awesome> ita: what's better to do?
<ita> focus on the features instead of the low-level annoying things
<Mr_Awesome> whats low-level and annoying to you is high-level and exciting to me
<Mr_Awesome> it beats hardwiring programs into circuitry
joshcryer has joined #ocaml
trrkkkkkk has quit [Read error: 113 (No route to host)]
<mbishop> So I heard Practical OCaml was a flop? that's sad, I want a good book (in english) for ocaml
<mbishop> Practical Common Lisp is great :/
<Mr_Awesome> too bad lisp is such a disappointment
<ita> lisp allows cool things like executing code from strings
<ita> the kind of things that is not possible from caml or c++ unfortunately
sponge45 has quit ["zzzzzzzzzz"]
<dan2> lisp is a terrible language
<Mr_Awesome> ita: lisp is a great language in theory, but in practice its unusable
<Mr_Awesome> besides, any dynamic language can evaluate code from strings on the fly
<ita> like hmm emacs ?
<dan2> ocaml is a great language with a lousy C interface
<zmdkrbou> lisp is a bad language in theory (and also in practice)
<ita> ocaml does not have anything dynamic
<ita> zmdkrbou: in theory ? why ?
<zmdkrbou> s/bad/dirty/ in fact
<zmdkrbou> ita: evaluating strings as code is dirt
<ita> zmdkrbou: what if i need it ?
<Mr_Awesome> <ita> ocaml does not have anything dynamic <-- your point?
<zmdkrbou> lisp it totally dynamic and dynamic is bad (imo) ...
<Mr_Awesome> zmdkrbou: i agree that dynamic is bad, but you have to admit the brilliance of lisp's simplicity
<Mr_Awesome> and orthogonality
<ita> zmdkrbou: what if i need to execute scripts from within a program ? shall i make another interpreter in another language ?
<dan2> Python is Dynamic and it's not bad
<zmdkrbou> python is cool but bad since dynamic :p
* zmdkrbou like python a lot, but that's dirty as well as lisp
<zmdkrbou> +s
<ita> zmdkrbou: and for my question right above ?
<zmdkrbou> ita: boarf, as a script language, yes, why not use it, but ...
<Mr_Awesome> ita: why do you need to make an interpreter in *another* language
<zmdkrbou> i don't like unsecure languages
<ita> Mr_Awesome: can you interpret caml in caml ?
<zmdkrbou> ita: you can write a caml interpreter in caml
<Mr_Awesome> ita: ah i understand now
<ita> zmdkrbou: examples ?
<zmdkrbou> ocaml ? :)
<ita> ...
<Mr_Awesome> however, ocaml has a library that allows very easy processing of ml-like languages
<ita> where is it ?
<Mr_Awesome> in the standard library
<zmdkrbou> and ocamllex and ocamlyacc
<ita> very funny
<zmdkrbou> ita: i don't get your point. ocaml is indeed written in ocaml, so what ?
<ita> zmdkrbou: do you have an example of executing caml code dynamically from a caml program (compiled) ?
love-pingoo has quit ["Connection reset by pear"]
<zmdkrbou> aah ok
<Mr_Awesome> ita: Genlex
<zmdkrbou> executing caml code dynamically is a strange idea, the main idea is to have static typing .....
<ita> zmdkrbou: exactly, but when i need to execute arbitrary code (yes, scripts), i need to re-implement another language - how cool
<bluestorm> hm
<ita> and since dynamic loading of shared libraries are not supported either it is of no use
<bluestorm> you can call the system to compile the code you want
<bluestorm> and the load it
<bluestorm> can't you ?
<Mr_Awesome> ita: have you looked at the dynlink library, which is part of the ocaml stdlib?
<ita> bluestorm: does dynamic loading of shared libraries work ?
<ita> Mr_Awesome: i did
<Mr_Awesome> ok
<zmdkrbou> ita: arbitrary code ? why don't you use a pre-existing script language ?
<ita> Mr_Awesome: works for bytecode, not for native binaries, right ?
<Mr_Awesome> correct
<ita> then it is of no use
<bluestorm> hm
<bluestorm> it's bytecode only
<bluestorm> but hey
<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.
<bluestorm> hm
<zmdkrbou> some of the people who were working on GHC (and were people from research in universities) were hired by MS
<bluestorm> we can see that 3 or 4 peoples have a @microsoft.com mail
<bluestorm> but i wouldn't say "it's developped by employees of MS"
<bluestorm> hm zmdkrbou
<trrkkkkk> It's not a big mystery if you're a regular on any of the mailing lists.
bluestorm has quit ["Konversation terminated!"]