This is the mail archive of the mailing list for the guile project.

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]

Re: Pliant

> IB> All languages have an internal representation -- a parse tree,
> IB> Java bytecodes, machine code, strings, or in Scheme's case, lists

> IB> and symbols (this may not be the case with every Scheme
> IB> implementation, but they hide that fact).  Why is Pliant's
> IB> internal representation more neutral than Scheme's?
>Don't confuse languages with implementations.  Scheme has no `internal

>representation' per se.  

I guess I'd mean that at certain points there's a representation which
is made available to the outside.  In the case of Scheme there's the
ASCII text and the result of a 'read'.  The result of a read is similar
to a parse tree, which is kind of one step below any syntax.  It looks
like Pliant makes a few more levels available, primarily to allow

> IB> And from what I can see from the website, Pliant seems to
> IB> emphasize efficiency a great deal -- I don't think Guile shares
> IB> this emphasis, it is meant as a compliment to more efficient
> IB> languages (like C).  Pliant seems to have a quite heavy compiling

> IB> phase.
>That's why I'm saying that Guile and Pliant can complement one another.

In what way were you thinking?

>As to your comments about debugging, I encourage you to read the
>documents on error handling.  Pliant's low-level error mechanisms can
>implement all sorts of crazy things like throw and catch.

I didn't read through much about the finer points of Pliant, just the
design document (I can't remember the name).  The problem I see is a
matter of perspective.  I guess I don't like the Algol family of
languages and the things that they emphasize -- Correctness and speed
above high-level features like GC, debugging, and rich libraries. 
Pliant seems to be a reaction to C and C++ -- and while it's definately
a move in the right direction from those languages it takes on the same
assumptions that they do.  

So while debugging may be possible, I wonder if there's the will to make
it really happen.