I have no formal programming background - so my experience won't be the case
with the majority of the people on this list.

I spent 2.5 months reading and re-reading the OCaml OReilly book... and
finally I 'understood' when you're supposed to use either a semi-colon,
double semi-colon, or nothing at the end of a line of OCaml code. Once I had
that breakthrough, I could 'think' OCaml. Ever since then I've been amazed
at how quick I can write very simple programs. The problem is that I mostly
write multi-user server apps, and that isn't so 'quick' to do in OCaml -
Ruby OTOH is ofcourse very quick to write almost anything you want.

Remember - OCaml is based on Lambda Calculus... which I really don't know
that much about, just that there's only three things in LC... a function
that accepts one argument, an argument, and the application of that single
argument to a single function... or somethign like that... SO... thinking in
OCaml is _nothing_ and i mean _nothing_ like thinking in C, or Java, or
Ruby, or Perl.

Here's a snippet of code from a 2 user socket server that does polling over
the connections... (yes, I know, no comments, and should have been expanded
at ';;'s. Remember - I'm not saying I'm good at this, I just get the job
done. ;-))

START CODE
let p=(int_of_string Sys.argv.(2));;let myAddr=(Unix.inet_addr_of_string
(Sys.argv.(1)));;
let sockaddr=Unix.ADDR_INET(myAddr, p);;let sock=(Unix.socket Unix.PF_INET
Unix.SOCK_STREAM 0);;
Unix.bind sock sockaddr;;Unix.listen sock 2;;
let (s,scaller)=Unix.accept sock;;let sOut=Unix.out_channel_of_descr s;;let
sIn=Unix.in_channel_of_descr s;;
let (t,scaller)=Unix.accept sock;;let tOut=Unix.out_channel_of_descr t;;let
tIn=Unix.in_channel_of_descr t;;
output_string sOut "Connected\000";;flush sOut;;output_string tOut
"Connected\000";;flush tOut;;
let this=ref ([s;s],[s;s],[s;s]);;
let sH=ref (String.create 1024);;let tH=ref (String.create 1024);;
sH:="";;tH:="";;
let sF=ref 0;;let tF=ref 0;;
let rS m= (if((!tF)=0) then (tH:=input_line sIn;tF:=1;print_string
"|s|";flush stdout));;
let rT m= (if((!sF)=0) then (sH:=input_line tIn;sF:=1;print_string
"|t|";flush stdout));;
let wS m=if((!sF)=1) then (output_string sOut (!sH ^ "\000");flush
sOut;sH:="";sF:=0;print_string "-s-";flush stdout);;
let wT m=if((!tF)=1) then (output_string tOut (!tH ^ "\000");flush
tOut;tH:="";tF:=0;print_string "-t-";flush stdout);;
while true do
 try (
  print_string ".";
  flush stdout;
  this:=Unix.select [s;t] [s;t] [s;t] (-.1.0);
  match !this with _,_,[w] -> (print_endline "error";exit 0)
   | [w],[],_ -> (if(w=s) then (rS w) else (rT w))
   | [],[w],_ -> (if(w=s) then (wS w) else (wT w))
   | [w],[x],_ -> (if(w=s) then (rS w) else (rT w);if(x=s) then (wS x) else
(wT x);)
   | [w;x],[],_ -> (if(w=s) then (rS w;rT x) else (rT w;rS x))
   | [],[w;x],_ -> (if(w=s) then (wS w;wT x) else (wT w;wS x))
   | [w],[x;y],_ -> (if(w=s) then (rS w) else (rT w);if(x=s) then (wS x;wT
y) else (wT x;wS y))
   | [w;x],[y],_ -> (if(w=s) then (rS w;rT x) else (rT w;rS x);if(y=s) then
(wS y) else (wT y))
   | [w;x],[y;z],_ -> (if(w=s) then (rS w;rT x) else (rT w;rS x);if(y=s)
then (wS y;wT z) else (wT y;wS z))
   | _,_,_ -> ()
 ) with End_of_file -> (print_endline "exiting";exit 0)
done;;
END CODE

OCaml native code is ~better~ than C - see the language shootout to
understand what I mean.

OCaml bytecode has all the benefits of Java - plus none of the failings
(development time is shorter by far - my OCaml skill compared to my
comparably skilled Java oriented brother).

OCaml toplevel is just like IRB, there are some quirks, but it's great for
testing a quick snippet of code before you end up using it.

OCaml is wonderfully easy to compile to a 'native' exe (I had to distribute
the cygwin.dll with it) or 'close-to-crossplatform' bytecode (I think some
libraries didn't exist for certain platforms, but my memory is hazy on that
point), and super easy to run in a toplevel interpreter.

The bad points - exactly the same as Ruby. Next to no corporate backing
(think Sun's marketing pocketbook), next to no 'real-world' uses even though
they also have a 'these-are-the-real-world-uses' page just like Ruby.

There is one drawback that hurt me alot - and it might have just been me...
I was very offended by the nuby mailing list responses I recieved... that
list is not for nubies. You've been warned. :-)

That's my simple opinion.

When people ask what languages I like most, I say Ruby first, OCaml a very
close second - and no... I really have no clue how to write C or Java... and
I really don't ever want to learn ;-).

-Rich

----- Original Message ----- 
From: <prosys / chartermi.net>
To: "ruby-talk ML" <ruby-talk / ruby-lang.org>
Sent: Saturday, August 16, 2003 8:30 PM
Subject: Rite/Ruby2.0 & Ruby vs OCaml


> Hi All,
>
> I'm new here, and I hope I don't offend anyone by mentioning a
> different programming language here on Ruby-Talk.
>
> I have two questions that are borne of the fact that I have been
> searching for a language that provides both rapid development
> (via an interperter) and performance (via compilation to either
> byte- or native code).
>
> I understand that Ruby is being developed towards the realization
> of a VM for byte-code execution.  My question is, will the
> interpreter function of Ruby remain?  Will I be able to have the
> best of both worlds -- rapid development _and_ performance?
>
> I looked at the comparison of various computer programming
> languages at The Great Computer Language Shootout
> [http://www.bagley.org/~doug/shootout/] and was a bit
> disappointed to see Ruby rated as low as it was in performance.
> This is the only reason I have not yet adopted Ruby.
>
> I did notice OCaml (Objective Caml) at the top of the list -- 
> right up there with C.  And, in my investigation, I discovered
> the OCaml can be run as a script interpreter _and_ that it can
> also compile byte-code and native code!  Wow -- just what I've
> been looking for.  But for some strange reason, I am still drawn
> to Ruby.
>
> Could someone please offer a comparison between OCaml and Ruby?
>
> Thank you all for your time.
>
> Best,
> Terry
>
>