Re: [Pika-dev] xl, xxl, and mxl

[Jeremy Shaw]

At Sun, 05 Sep 2004 22:32:38 +0200,
Jose A. Ortega Ruiz wrote:
> 
> [1  <multipart/signed (7bit)>]
> [1.1  <text/plain (7bit)>]
> Jeremy Shaw <address@hidden> writes:
> 
> >
> > The site is a bit light on details, but it seems like using scheme 
> > would bring a whole host of disadvantages -- run-time type errors, 
> > non-termination, etc.
> >
> 
> Hm. I won't enter in yet another debate of static vs. dynamic typing,
> but i don't really see how Make is free from the (potential) drawbacks
> you mention (writing a non-terminating makefile, or a non-terminating
> program in any language for that matter, seems rather straightforward).

I do not mean to say that make is free of those problems, just that is
should be :) On the other hand, make does do better in those two areas
than some other langages.

In make there is pretty much just one type, 'lists of strings', so,
not much can go wrong in terms of type errors. And make tries to be
smart about detecting non-termination.

For example, if you try this:

target1: target1
        touch target1

You will get:

 $ make 
make: Circular target1 <- target1 dependency dropped.
touch target1
 $

And if you try to be sneaky and do:

target1: target2
        touch target1

target2: target1
        touch target2

 $ make
make: Circular target2 <- target1 dependency dropped.
touch target2
touch target1
 $ 

Of  course, this will still cause trouble:

target1: target2
        make -f Makefile
        touch target1

 $ make
make -f Makefile
make[1]: Entering directory `/root/tmp'
make -f Makefile
make[2]: Entering directory `/root/tmp'
make -f Makefile
make[3]: Entering directory `/root/tmp'
make -f Makefile
make[4]: Entering directory `/root/tmp'
[hit cntl-c]
make: *** [target1] Interrupt
interrupt
 $

And, of course, make lets us call bash, so we can do:

target1:
        (while true ; do sleep 1 ; done)


Writing a non-terminating program in most languages is trivial. Indeed
so trivial you might do it by accident. If make did not allow you to
call out to the shell (which would also make it pretty useless), I am
not sure that you could write a non-terminating makefile.

xl has the same property, there are no built-in language features that
will allow you to express non-terminating programs. One natural side
effect of this is most type errors can be statically detected. Another
natural side effect of xl's design is that it is very easy to run an
xl program on a parallel processor or distributed system, aka, do a
make -j4.

I guess I would be interesting in seeing more information on *why* you
think make needs to be replaced. What do you hope to achive that can
not be done by improving the existing make (ie, in what ways is make
fundamentally broken)? I think there are some pretty good arguments
for why make is fundamentally broken, but seeing what you feel is
wrong would help me understand where you hope to go with conjure.

Jeremy Shaw.
--

This message contains information which may be confidential and privileged. 
Unless you are the 
addressee (or authorized to receive for the addressee), you may not use, copy 
or disclose to anyone 
the message or any information contained in the message. If you have received 
the message in error, 
please advise the sender and delete the message.  Thank you.