

Guile 2.0 is out - vu3rdd
http://article.gmane.org/gmane.lisp.guile.devel/11654

======
mwexler
For those who have lost count of the zillions of languages out there, this is
a Scheme interpreter/vm that was supposed to become the "official" extension
language for GNU projects. It had some publicity in the 90s, but slowed down
until recently.

Sorry to be simplistic, but so many links here assume everyone is an expert in
functional programming; a little context helps everyone understand the
importance of a post.

~~~
pmarin
This information is in the third paragraph.

------
oddthink
I still don't understand Guile. It makes sense as a stand-alone language
implementation, but not as an embeddable one. Why isn't it re-entrant? What
about multiple interpreters? Why a C-level GC like Boehm, rather than just
track your own garbage? Why scheme for an embeddable language, don't
continuations make C interop hard?

Even back when they announced Guile, it seemed odd that they based it on SCM
rather than on SIOD or TinyScheme.

Lua seems to be far superior for embedding. Guile seems big and invasive by
comparison. It seems to be heading squarely for that awkward middle size
between big/full-featured and small/light that hurt Tcl, as argued in
[http://journal.dedasys.com/2010/03/30/where-tcl-and-tk-
went-...](http://journal.dedasys.com/2010/03/30/where-tcl-and-tk-went-wrong) .

~~~
wingo
You raise some interesting questions, and some misconceptions. It's an ugly
format, but I'm going to respond point-by-point:

> Why isn't it re-entrant?

I'm not certain what you mean here; certainly you can call from C to Scheme to
C to Scheme, and do so concurrently from multiple pthreads.

> What about multiple interpreters?

Like arenas? Guile doesn't do this, no. I've never understood the desire for
this, either; if you want to isolate users, put them in different modules.

> Why a C-level GC like Boehm, rather than just track your own garbage?

Precisely for embeddability. Tracking your own garbage is hard in C. It's
doable of course, but very error-prone. Guile's C API is pretty easy to use
(IMO of course).

> Why scheme for an embeddable language, don't continuations make C interop
> hard?

We have continuation barriers, but it's true that our historical continuation
implementation has been a stack-copying one. In 2.2 we are likely to move to a
model where we just capture the Scheme stack.

That said, delimited continuations are really the bee's knees. See "Prompts"
in the manual for more.

> Even back when they announced Guile, it seemed odd that they based it on SCM
> rather than on SIOD or TinyScheme.

I think the thing was that folks wanted an implementation that could grow into
something more substantial. Which leads to your next point:

> Lua seems to be far superior for embedding. Guile seems big and invasive by
> comparison.

The problem is that once you have a nice small language, you start to want to
program more and more in it, and you end up with a nice medium-sized language.
You can see that even now with Alex Shinn's Chibi. It seems to be a hump you
have to grow over and then become a nice large language ;-)

Lua is wonderful, and they are among the few groups I have heard of that
manage to keep things small and lean. By all means, use it! But I think that
in the end, most things tend towards something the size of Python, and for
mostly good reasons.

~~~
jmillikin

      >> What about multiple interpreters?
      >
      > Like arenas? Guile doesn't do this, no. I've never
      > understood the desire for this, either; if you want to
      > isolate users, put them in different modules.
    

I think he means running two interpreters in the same address space and/or
thread. In Lua, a pointer to the entire interpreter state is passed around in
a ``lua_State * ``, so it's easy to embed without worrying about one
interpreter accidentally mucking with another. I believe Python does something
similar with ``PyInterpreterState * ``.

Based on the Guile API reference[1], it's not possible to safely run two Guile
interpreters in the same pthread. This makes it difficult to embed in
languages with alternative threading models.

[1]
[http://www.gnu.org/software/guile/manual/html_node/Initializ...](http://www.gnu.org/software/guile/manual/html_node/Initialization.html#Initialization)

~~~
oddthink
Yes, that's it exactly.

I've grown more and more averse to implicit state. I like that in Lua, all my
interactions with the interpreter are mediated by the lua_State. If I want to
run two at once, I can. If I want to store a Lua object for later use, I can
stash it in there. If I want to have a globally-available state for my
programs, I can implement it myself as a global. Nothing is mucking around
with the call stack looking for things that "look like a pointer."

A few years ago, I wanted to embed a scripting language into a monster of a
multithreaded C++ application, which (oh joy) was using RogueWave threads
rather than straight pthreads. I tried python, but couldn't figure out how to
get the thread locking to work properly; python had its own ideas about how
the threading should work.

Then, I tried Lua. With Lua, I could just implement a pool of properly-
initialized interpreters, then assign them out to each thread on need. It
worked very well.

------
mhd
Guile was RMS' counter-argument to tcl as an extension language back in the
days, right? And wasn't it supposed to be a possible elisp replacement, too?

It would be very nice if someone could summarize the current state of the
language, i.e. why one would use it instead of Racket or Gambit.

~~~
wingo
As far as history goes,
[http://www.gnu.org/software/guile/manual/html_node/History.h...](http://www.gnu.org/software/guile/manual/html_node/History.html)
is where it's at.

------
mapleoin
Is anyone using guile for any fun project? Or are there any fun projects to
work on with guile?

I would love to learn Scheme as my next hobby language and guile seems like
the way to go with all the things that have started to happen with it lately.

~~~
loewenskind
Personally I would prefer Racket over Guile, but if it starts to keep its
promise about becoming _the_ scripting language for linux then I would get
more interested.

Any link for all the things that have started to happen with it lately for
those of us who are out of the loop?

~~~
mapleoin
I guess I've just seen quite a few releases lately that were also broadcast
via HN.

There was also a previous discussion about guile's webby features:
<http://news.ycombinator.org/item?id=2017419>

------
srean
Debian testing(wheezy) lists version 1.8.7. Any chance this will get into
wheezy ? Love the fact that Guile has picked up a lot of steam.

~~~
mapleoin
This isn't exactly the right place to ask this sort of questions. Why not
email your distro's guile maintainer? Or open a bug report. Or just search for
an already existing discussion on this topic on Debian's usual maintainer
communication channels.

~~~
bryanlarsen
If the author thinks others might be interested in the answer, this is exactly
the right place for this type of question. Sure, it's not going to get upvoted
to the top of the page, but it's the type of constructive question and answer
that belongs near the bottom of a comment thread. Both Debian & Guile are
interesting to hackers, and there would be a large overlap between the type of
hackers interested in Debian and the type of hackers interested in Guile.

~~~
mapleoin
You could make the same argument for Fedora, OpenSUSE, Ubuntu and others and I
don't think it would be a good idea to have threads for all of those in this
discussion.

------
igneous4
In what ways is Guile different from other Schemes, such as Gambit and
Chicken?

Is Guile a good Scheme to start off with when first learning Scheme?

~~~
krakensden
It's easy to embed, it also has (had?) a Javascript-syntax mode.

Racket is what most people recommend for learning.

------
chalst
The meta command support in the new REPL looks like it is copied from
Scheme48.

How does Guile compare to scsh these days?

~~~
wingo
It is indeed copied from some other Scheme, though I can't recall which.
Rather embarrassingly, I've never fired up Scheme48, or used the original
scsh.

Lots of the POSIX bits in Guile were inspired by scsh though, originally
anyway. Most of those pieces are 10+ years old.

There are ports around for scsh; googling "guile scsh" will lead you to a few.
But there is no proper package with a proper manual.

~~~
chalst
Command language: Look at chapter 3 of the s48 guide at
<http://s48.org/1.8/manual/manual-Z-H-4.html#node_chap_3>

Scsh: There was a whole lot of noise and some code about supporting Scsh on
Guile early last decade, as there was for PLT Scheme, but both seem to have
run out of steam. I think that replicating Scsh is harder than it looked at
first.

I'm really pleased to see the work on the command language and bytecode
interpreter. Scsh is something I've built a few times, but never got into.
First the sounds of progress on the Emacs/guile front and now this look
positive: it's a good time to take another look at Guile.

~~~
chalst
s/Scsh is something/Guile is something/

------
sigzero
Is there a Windows version to play around with?

------
vu3rdd
Guile also comes with a high quality manual ~ 800 pages long, thanks to the
tireless work by Neil Jerram and others.

------
rmjb
People looking for a tiny, embeddable scheme should also check out Alex
Shinn's chibi-scheme.

