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: Direction

>>>>> "Lalo" == Lalo Martins <> writes:

    Lalo> I feel that the current discussion about defined? and
    Lalo> undefine is a sign of Guile's worst weakness; and that is,
    Lalo> IMHO, lack of direction.

I think it appears that way because there are no killer apps out there
that are forcing GUILE to adopt new features.  Guile is lacking
polish, not features.  Consider where the current effort is going:
Rewriting a working module system.  Improving an existing garbage
collector.  Implementing a variant of an object system that already
runs in GUILE (tinyclos).  I'm glad these are all happening, but guile
is a good extension language without any of them.

    Lalo>   What ========

    Lalo> The objective of Guile, as I see it, is to develop a
    Lalo> powerful extension language (emphasis: extension, not
    Lalo> scripting). Is good to know it's possible to create
    Lalo> all-Guile software, but this is not the primary goal. Anyone
    Lalo> disagrees?

To my mind, any powerful extension language is almost by definition a
powerful scripting language.  Just to give a data point, in my work
>>99.9% of the code is C or F77 (by line count), but I spend most of
my time working in GUILE writing scripts that use the libraries.

    Lalo>   How =======

    Lalo> Even if we agree on above, this doesn't say a lot. There are
    Lalo> many concepts of "powerful" and many ways to get there.

    Lalo> These are the three major directions I see people trying to
    Lalo> pull Guile to:

    Lalo> 1: generic extension library/interpreter. This is the
    Lalo> direction we advertise the most, and the one chapioned by
    Lalo> projects like CTAX, tcl->scheme, Sonya, etc. If this is the
    Lalo> path we want to follow, the priority should be in constructs
    Lalo> to allow bizarre Perl and Python constructs (one example
    Lalo> that comes to mind: Python's "type" type)

I'm dubious that this will work.  GUILE can never hope to be as good
an implementation of Perl as Perl.  Most of the target languages have
too many undocumented idiosyncrasy.

    Lalo> 2: a powerful Scheme implementation. Everytime I see "but
    Lalo> Scheme does this by..." or "the standard doesn't have this"
    Lalo> or "this is not schemely" I realize how powerful this
    Lalo> "party" is.

I hope Guile won't try and compete with Scheme implementations that
are purely Scheme.  

I think a good third is:

  3) An extension language based heavily on Scheme, but with
     many powerful extentions.

In my opinion, GUILE main strength is that it uses a "real language"
as it's base.  By this, I mean a language that was designed to solve
general computing problems.  This is in direct contrast with TCL and
Perl which were designed to solve special purpose problems.

I'm always glad when new features are implemented in a "schemely" way,
and when GUILE doesn't duplicate features that are already part of
Scheme in a slightly incompadible way.  I hope that GUILE continues to
follow rnrs.  I hope that GUILE will not deviate too far from it's
Scheme heritage.  On the other hand, GUILE should not be fettered by
the rather minimalistic scheme view of the world.

    Lalo> Most people could care less for Scheme.

    Lalo> Scheme isn't easy to learn...

That's true, but I think a more correct statement is "Programing isn't
easy to learn".  Personally I found Scheme much easier to learn and
use than Perl, and I've written far more Perl.  Even after using it
for a long time, I still need the manual on the desk to weave my way
through Perl's web of inconsistencies.  I find it such a nightmare
that I dread starting new projects in Perl and I loath maintaining the
once I work on.

The trick is that I've never seen a good friendly introduction to
Scheme.  Everything I've seen starts out something like "Hey, we can
write a neat recursive factorial function in 33 keystrokes."  Yes I'm
exagerating, but seriously scheme tutorials are not aimed at computer
phobes.  Compare that to the Perl book whose first chapter essentially
says, "relax, it's not that hard" and then gives lots of seemingly
simple examples.

    Lalo> Why must SIAG, one of the greatest Guile champions, have
    Lalo> Python and TCL interpreters?

I'm not familiar with SIAG, but if SIAG wants to allow extensions in
Python and TCL, why shouldn't it have those interpreters?  Isn't it
better to have the real languages available rather than some similar
by subtly different knock-off?

    Lalo> Perl and TCL are the most used languages. Python is famed to
    Lalo> be the easiest to learn. Unless we have an
    Lalo> interpreter/library that can read all three of them, I don't
    Lalo> think people will care.

I think it's a mistake to try and be all things to all people.  I hope
that GUILE focuses on being a killer scheme based extension language.