
GNU Guile 2.0.10 - lelf
http://lists.gnu.org/archive/html/info-gnu/2014-03/msg00006.html
======
Steltek
Guile is a great little Scheme. I found it to be a very welcoming environment
to program on Linux and I'm having a ton of fun relearning Lisp with it.
Having tried using SBCL as a "Unix-ing with Lisp", Guile was so much easier.
It Just Worked the way I expected when touching the OS, compared to CL's crazy
filepaths and time epoch.

I've also greatly enjoyed reading the compiler/VM backstory on
[http://wingolog.org/](http://wingolog.org/) . It occurs to me that if you
have an efficient Scheme VM, you could use it as a target for a lot of other
languages and get something of an 100% OSS .Net or Java polyglot ecosystem
going. Parrot was the previous hope but it seems to have fallen into being a
mostly academic exercise.

And then there's "GuileMacs", which seems to get closer to a reality with
every push. Not being a native Lisper, I think Emacs could use a boost from
having a faster VM and lexical scope.

Really there's just a lot to love about Guile. I'm excited about all the
activity and attention it's getting.

~~~
cookrn
I'm hopeful for Rubinius w/r/t a long-term viable polyglot VM. It has _lots_
of languages built for it but Ruby is still its most popular and mature as far
as I know.

[http://rubini.us/](http://rubini.us/)

~~~
e12e
I wasn't aware Rubinius was a polygot vm -- but are there _any_ usable
languages ported other than Ruby? Both the Smalltalk and Python port appear to
be unfinished and abandoned?

~~~
cookrn
Fancy[0] is one of the most mature languages on the VM other than Ruby I
believe.

[0] [https://github.com/bakkdoor/fancy](https://github.com/bakkdoor/fancy)

------
josteink
As someone who has merely dabbled lightly with Scheme, what's the main issue
with Guile?

Looking on the outside it looks like its a decent Scheme and the problem is
lack of use and adoption (like in Emacs). Is that a correct assessment, or is
the lack of adoption caused by issues with the implementation itself?

Or am I just all wrong about the state of Guile itself, and it's quite widely
adopted, just that nobody speaks too much about it?

~~~
muuh-gnu
The main issue with Guile is the same issue as with any other Scheme, and that
issue is that it is a Scheme. No single Scheme is widely adopted and the main
reason for that is extreme balkanization. You dont write code in Scheme, you
write Guile, Racket, Chicken, etc.

The Scheme philosophy, which was developed in opposition to batteries-included
aka "bloated" Common Lisp, was to have a small core and emphasize simplicity,
purity, etc. For years proponents of Scheme have emphasized how beautiful and
simple the small standard of 50 pages is, compared with Common Lisps "bloated"
1000+ pages standard.

This had two consequences:

1\. It was extremely easy to write a scheme implementation, soinstead of
writing code _in_ scheme, people wrote _schemes_. Hundreds of them. And while
other people spent the last 20 years writing thousands of useful libraries in
C, python, java, scheme implementors spent reinventing the wheel, over and
over and over and over again. Today there are more implementations of scheme
than libraries in scheme.

2\. The emphasis on "small core" might be cute for teaching SICP, but in order
to be able to do anything useful with the implementation, it forced the
implementors to reinvent the wheels for everything else. And each
implementation did it their own way because standardization was considered
"selling out" and aping the nemesis Common Lisp. This led to _extreme_ code
unportability.

Nowadays they are somehow trying to standardize, but with the consequence that
they are realizing that by doing that, they are becoming indistinguishable
from their old nemesis Common Lisp, which went through the same balkanization
phase 20 years ago, so the point of splitting off Scheme from Lisp is becoming
questionable. Instead of wasting precious time writing 1001 scheme
implementations, they could have spent the last 20 years writing useful common
lisp libraries and competing with other batteries-included languages like java
and python.

In short: Besides the social problems that every Scheme suffers from and the
Lisp world suffered during the 80s, Guile on its own is doing quite well. Once
it is integrated into Emacs, Emacs will become Guile's killer app, boost its
popularity and set it apart from other schemes.

~~~
gkya
I concur, with sorrow. Scheme is such a nice language... I believe a
standardised syntax to define compound data structures (aka _defstruct_ ) and
a standardised C FFI would make Scheme language usable. If these existed, I'd
implement a Leiningen-ish tool and a couple libraries for Scheme, to get going
with web development.

 _(There is one more problem I have with Scheme, which is the name. It sounds
identical to a vulgar Turkish word for "my penis"; resulting in awkward
situations when talking about the language in Turkey, where I live. :))_

edit:

    
    
      - the Turkish word  
      + a vulgar Turkish word

~~~
Flow
:-)

Do you say Sch-eme or Sk-eme? I think both are ok, but please correct me if
you are a native english speaker.

~~~
gkya
Sk-eme, as in school, or scam, not as in schweppes, or Schrödinger. I'm not a
native speaker, yet quite practised. And Sk-eme is how most pronounce the
name, as far as I've seen. You can't know how much I wish it was called plan,
plot or something :)

~~~
e12e
I'm pretty sure only /skiːm/ (as in skill) is correct.

------
davexunit
A lot of good patches in this release. I'm glad that Guile finally ships the
SRFI-64 testing API and the SRFI-111 boxes API.

I am the co-author of the cooperative REPL servers patch. This patch allows an
interactive programming environment to be integrated into applications that
are single-threaded and/or run an event loop. I am using cooperative REPLs for
a 2D game development engine written in pure Guile.

I highly recommend trying out Guile. The community is really great. I entered
#guile on freenode about a year ago when I knew nothing about Scheme and
everyone was friendly and helpful. I've since authored 3 patches and written
some pretty awesome programs with Guile.

To further entice you to give Guile a try, check out this post/screencast in
which I demonstrate functional reactive programming in the context of game
development:

[http://dthompson.us/functional-reactive-programming-in-
schem...](http://dthompson.us/functional-reactive-programming-in-scheme-with-
guile-2d.html)

Happy hacking!

~~~
radarsat1
What's up with Scheme naming packages "SRFI-some-number" instead of a
memorizable and meaningful name like every other language? It's one of the
things I find the most frustrating about Scheme.

~~~
davexunit
It's not quite right to think of SRFI's as libraries, because they are
specifications. They are numbered for the same reason why RFCs and other types
of specifications are numbered. In addition to their number, they also have
names. For example, SRFI-41 is named "Streams". SRFIs are API specifications
with potentially many implementations. Each Scheme implementation may
implement a SRFI a bit differently.

Talking about Guile specifically, there are a bunch of libraries with
"memorizable and meaningful names". guile-sdl, guile-json, guile-2d, guile-
compost, guile-ssh, guile-xcb, etc.

~~~
stewbrew
The missing link: [http://srfi.schemers.org](http://srfi.schemers.org)

SFRI = Scheme Requests for Implementation

