Version française
Home     About     Download     Resources     Contact us    
Browse thread
Estimating the size of the ocaml community
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: -- (:)
From: Erik de Castro Lopo <ocaml-erikd@m...>
Subject: Re: [Caml-list] The boon of static type checking
On Sun, 6 Feb 2005 01:02:42 +0100 (CET)
Thomas Fischbacher <Thomas.Fischbacher@Physik.Uni-Muenchen.DE> wrote:

> (1) Portability.
> 
> (2) A good compiler.
> 
> (3) The ability to create comparatively small standalone programs.
> 
> (4) Availability of essential constructions, such as closures.

The features I *REALLY* love in O'caml are pattern matching and higher
order functions (particularly currying).

> (5) Availability of useful libraries.

I would add:

  (6) Its far harder to shoot yourself in the foot using O'caml than
      it is in C or C++. In particular, in O'caml comapred to C++, if 
      it compiles, its far more likely to work.

> I think the points why I believe ocaml will never win over a noticeable 
> share of especially the lisp community 

Those guys are probably a lost cause :-).

> are clear now: there are some 
> quirks of the language that in the long run make working with it less fun 
> for lisp programmers than working with lisp

I'm a refugee from Python (among other languages) although I still do
use Python for some scripting tasks where O'caml is overkill. My big 
gripe with Python results from its dynamic typing. A large class of 
errors which are compile time errors in O'caml are run time errors in 
Python. I believe that Lisp is also (mostly) dynamically typed.

However, I find it interesting to look at O'caml from the perspective of
the Blub paradox:

    http://c2.com/cgi/wiki?BlubParadox

which holds Lisp as being the closest approximation to a superset of all
other languages. The main feature of Lisp which supposed puts it in this 
position is Lisp macros. I also hear that higher order functions are not
used as much in Lisp as they are in O'caml and that this is because of
Lisp's more lax type checking.

Drawing a long bow here, I would postulate that a language with O'caml's
HOF and strict typing and Lisp like macros, might be able to knock Lisp
off its perch. Maybe Nemerle (not that I've used it):

    http://www.nemerle.org/

is a language that is getting close to this goal.

> If I were to limit myself to naming only one ugly side of ocaml which I 
> would like to see changed, this would be the unavailability of automatical 
> printers for complicated composite nested data structures. 

I agree. It may be possible to address this with Nemerle's macro capabilities
or even camlp4.

Erik
-- 
+-----------------------------------------------------------+
  Erik de Castro Lopo  nospam@mega-nerd.com (Yes it's valid)
+-----------------------------------------------------------+
"... there's something really scary about a language (C++) where
copying state from one object to another is this complicated"
-- Richard Gillam