[jrq]

I love that GNU loves Guile. There are few Scheme implementations as well polished as guile is, and what a breath of fresh air it can be to sit down to some '() stew after a few rough weeks of spreadsheet hell at work.

Might be just me, but it's kind of like having another universe to take a vacation in.

It does make me miss types, doing data structure programming in scheme can be irritating I guess, but still. I can compose, I can syntax-rules if I wanted, etc.

The sexpr universe isn't dead yet.

[eadmund]

It's a pity GNU doesn't use Common Lisp instead of Scheme — it has rich types, data structures & more. It's a language built for programming large systems, rather than teaching small examples.

[jrq]

R7RS large is underway now! CL also has unhygienic macros, non-lispy loop grossness, lots of cruft, lots of poorly named functions that are named two different ways in two different places, and generally reeks of the 70s.

Scheme actually tried to compete with CL once, with a language called T. It had something sorta similar to CLOS and if I recall it was aiming for optimized performance per Sussman and Steele, but it eventually languished.

SBCL is the only thing keeping CL alive and they don't have the wherewithall to begin a modernized spec.

I don't hate CL, but I LOVE scheme. It is much more pleasant to actually work in, and feels cleaner. All the potholes of CL leave me checking under my fingernails for grime.

[lispm]

> generally reeks of the 70s

Scheme was implemented as a clean toy/educational Lisp on top of Maclisp in the mid 70s.

Scheme was defined too small upto R5RS and in R6RS is got unlispy.

> Scheme actually tried to compete with CL once

It never really did, since all implementations were different. There are lots of great Scheme implementations (MIT Scheme, Chez Scheme, ...) - but all were different. Then a bunch of extension were bolted onto Scheme - but the base was too small.

> It is much more pleasant to actually work in, and feels cleaner.

Which Scheme? Chicken Scheme? Racket - which is no longer a Scheme? Kawa? They are cleaner than CL?

The last clean Scheme was R5RS - and that was underspecified as a programming language.

Whenever I used Scheme I missed keyword arguments, CLOS, LOOP, optimization declarations, type declarations... Oh, wait. All those and much more has been added to Scheme in some ways. Unfortunately the result does not look 'cleaner'.

Chicken Scheme:

    (define-method (pop (stack <stack>))
      (let* ((c (slot-value stack 'content))
             (x (car c)))
        (set! (slot-value stack 'content) (cdr c))
        x))

Let's see how it's written in Common Lisp:

    (defmethod stack-pop ((s stack)) 
      (pop (slot-value s 'content)))

[eadmund]

> CL also has unhygienic macros, non-lispy loop grossness, lots of cruft, lots of poorly named functions that are named two different ways in two different places, and generally reeks of the 70s.

That's all true enough; I believe that non-hygienic macros are a vital capability of a programming language (and Common Lisp being a Lisp-n makes them much less of a problem), and that LOOP is okay. I don't mind the cruft much: it's a mostly-backwards-compatible language, and backwards-compatibility is important; it's why Lisp code from the 80s can still run now, almost 40 years later.

I don't hate Scheme, really: it's a very neat little language. But it's completely unsuited for production work on large systems, which are what I'm interested in. Case in point: call/cc. It's nifty, really cool and absolutely has no place in any production system — it's ultimately just a very-lightly-structured GOTO.

[p_l]

I find it rather rare for GNU to actually use (any) lisp or support it. Sometimes I have a feeling that only a few hard working people somehow carry the torch of Guile as standard extension language of GNU project. :(

[jrq]

Guix uses it extensively. I'm away from a computer now but I'm sure there are some gifted minds working on it. Andy Wingo, others.

And anyways, isn't that the case with most software? HN loves APL, but there's only a few implementations around any more, Arc used to be the big topic of HN, it's all but dead, software comes and goes.

Scheme will die someday, or change enough that its something different, but the lessons of programming with linked lists and eval will stick around in those that bother to learn them. Ie, people like you and I.

Maybe you should check the Savannah repo. Maybe they need some work done that you could do!

[gnulinux]

Is it really "another universe" for most people? I thought python is a pretty popular language and it's hardly more type-safe than scheme.

[jrq]

I don't understand what you're asking. Python is completely unlike scheme.

The type situation irks me because I do ocaml for a living, so I rely on the type system a lot. Scheme reminds me of a more seductive flavor of FP, though sometimes it's cumbersome to ensure that a data structure isn't being subtly changed somewhere.