Re: [Caml-list] Haskell vs OCaml

[Peng Zang <peng.zang@gmail.com>]

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1


On Thursday 14 August 2008 09:28:34 am Peng Zang wrote:
> OCaml let's you write however you think about it.  Haskell makes you think
> about it in *the haskell* way.  Sometimes this is good because it forces
> you to do certain things.  Othertimes it just gets in your way.
>
>
> Peng


Haha, I have some free time.  So, let me explain more about why sometimes it's 
good that Haskell makes you do things in a certain way.

One is that Haskell forces your program into two parts.  Parts that contain 
side-effects (in monads) and the part that is pure.  This is great because 
the compiler can now do some optimizations not available when you don't know 
if your code is pure.  This is also good because side-effects can be 
confusing and difficult to maintain over time.  By putting all the side 
effects in a box, you can compartmentalize it away.  For lots of changes you 
only have to consider the pure stuff which is easier to think about (no 
worries about state, no worries about the right order of doing things, 
program in a declarative fashion).  The downside is you have to put all the 
side-effect stuff in a corner and box it off.  This can be a little odd 
because it may make you organize your code in a counterintuitive way.  Also 
it makes side-effect creep very obvious (when you realize "oops, that needs 
to be in a monad too... and that... and that ... crap").  You really have to 
sit down and think about the design before you do anything.  Haskell is 
definitely a first-on-paper, then-in-code type of language.  This can be good 
because for complex stuff you probably want to think about the design ahead 
of time anyways.  Haskell forces this discpline on you.  On the other hand, 
if you like to do rapid prototyping type of approach and live on the edge a 
bit, it can be a bummer.

A similar argument follows for lazy (non-strict) evaluation as well.  Allows 
some really cool stuff (eg. infinite lists) and optimizations (eg. 
deforestation).  But has significant overhead (eg. you have to make a thunk 
for everything, if you're going to evaluate it anyways, all that work to make 
the thunk is wasted) and it's hard to reason about speed and memory 
performance (eg. it looks like a tail recursive function that uses constant 
stack space but because the accumulator is thunked, you end up creating O(N) 
thunks).

Anyways, I think Haskell has some really cool ideas and I like it.  It 
definitely expands the mind.  But OCaml is my go-to-swiss-army-knife of 
languages.  It used to be C but that was too low level for me and library 
support was crap (this was before Boost).  Then it was Java but it was waay 
to verbose and you couldn't even return a tuple without creating a class for 
it first.  Then it was Lisp, but it's dynamically typed and I got tired of 
finding bugs from 3 years ago.  Now days it's OCaml.  Maybe one day it'll be 
something else, but in the mean time, I'm enjoying it.

Peng
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v2.0.7 (GNU/Linux)

iD8DBQFIpDq+fIRcEFL/JewRAv3eAJ9L3W43Qfn2bFpLpUiyRt4Dn1dt6gCeNvew
8w6kCN5AKcGJH8WYzJPyKVM=
=6HsO
-----END PGP SIGNATURE-----