GNU Guile beta 2.1.3 released

[rsfinn]

TIL: In the year 2016, twenty-two years after the publication of "The UNIX-HATERS Handbook"[1], sendmail still finds it necessary, upon discovering the word "from" at the beginning of a line in the body of a mail message, to replace it with the string ">From".

[1] http://web.mit.edu/~simsong/www/ugh.pdf

[jjnoakes]

The real bug is not the replacement (the quoting), but the failure to reverse it (unquote) at the proper times.

(The From to >From quoting design itself can be argued to be a poor decision, but that is orthogonal to the issue of why >From appears in random places. If the unquoting was done properly by all systems involved, there would be no >From in the wild).

[davexunit]

I was wondering what was up with that. Thanks for the history lesson.

[ianleeclark]

"The new internals will eventually allow for user-space tasklets or green threads that suspend to a scheduler when they would cause blocking I/O, allowing users to write straightforward network services that parse their input and send their output as if it were blocking, while under the hood Guile can multiplex many active connections at once."

Green threads in the future sounds really interesting. I've never touched scheme (only dabbled in Clojure), but I've always wanted to get a Lisp under my belt. Maybe Guile will be the one, but the biggest issue for me in choosing a Lisp is the sheer amount. It's hard to know the true tradeoffs between different implementations, so maybe I should just go with Common Lisp

[DigitalJack]

I personally found clojure to be the most enticing lisp, and the only one I've gotten off the ground with. Enticing because it does web apps so well, which makes it practical (in my mind) and gives that sense of accomplishment.

That said, there are some crazy advanced things you can do in lisps, and I'm sure I've only scratched the surface. But that scratch was deep enough to build things that are useful.

Another interesting thing is that some people's clojure code is very readable and understandable to me, like James Reeves' (weavejester) code. Other people's code is very difficult for me, David Nolen's for example (swannodette). Not saying one is better than the others, more of having a familiar way tackling a problem in code I suspect.

I can't say I ever had an A HA! moment with lisp like some famous people have described, but I can say that I am a better programmer for having gone down that road.

I didn't realize it had had any positive impact on my understanding until recently when I decided to give Haskell another try. Lo and behold, I am actually understanding it now (via learn you a haskell), and I'm struggling to understand what was so hard about it before. I can't say exactly what changed, but something did.

I can't say it was because I specifically learned a lisp, it might have been just as true if I had learned OCaml or some other language. But I am suspicious that it was because it was a lisp.

I can say this, I have had an A HA! moment with Haskell. It was more of a Holy Sh*t moment for me actually. And that was when I got to the quicksort example in Learn You a Haskell. I was stunned.

[davexunit]

Part of the async i/o solution for Guile involves "prompts" (more formally delimited continuations) that allow defining new types of control flow operators. Here's a simple cooperative multitasking implementation and a contrived example program that uses it:

    ;; Core implemenation
    (define (call-with-coroutine thunk)
      "Apply THUNK with a coroutine prompt."
      (define (handler cont callback . args)
        (define (resume . args)
          ;; Call continuation that resumes the procedure.
          (call-with-prompt 'coroutine-prompt
            (lambda () (apply cont args))
            handler))
        (when (procedure? callback)
          (apply callback resume args)))
    
      ;; Call procedure.
      (call-with-prompt 'coroutine-prompt thunk handler))
    
    (define (yield callback)
      "Yield continuation to a CALLBACK procedure."
      (abort-to-prompt 'coroutine-prompt callback))
    
    ;; Simplistic example
    (define *cont* #f)
    
    (define (pause)
      (yield
       (lambda (cont)
         (set! *cont* cont))))
    
    (define (resume)
      (*cont*))
    
    ;; Prints "foo"
    (call-with-coroutine
     (lambda ()
       (display "foo\n")
       (pause)
       (display "bar\n")
       (pause)
       (display "baz\n")))
    
    (resume) ; prints "bar"
    (resume) ; prints "baz"

[jarcane]

I really recommend anyone getting started with a Lisp to just start with Racket. It's easily the most complete out of the box as well as the most user-friendly to get started with.

I've come to love Clojure as well, but it is ... idiosyncratic as a Lisp and not very user-friendly when it comes to mistakes, and I think it's good to get a grasp on the basics in a Scheme-based dialect.

I can't honestly recommend Common Lisp at all. Where Clojure is idiosyncratic, at least there's a driving logic behind it. CL is a product of design by committee in the worst way, and even many of the basics are needlessly confusing to a beginner.

[PeCaN]

If you actually want to develop applications you should probably stick to Common Lisp. SBCL and ClozureCL are extremely high-quality implementations and Common Lisp generally has the most libraries.

It's probably the worst Lisp from a design standpoint, but the best from a practical one. Racket seems interesting in that regard however.

If you want to embed a Lisp in a larger application, Guile is definitely good with an easy API and high-quality implementation.

[zvrba]

Is it just me who has the impression that Python "won" as a glue and application extension language?

[PeCaN]

Yes, I think it is.

Lua "won" in games, Tcl won in electrical engineering software, Lisp won in various niche places, JavaScript won basically everywhere else.

Python does not seem a very popular glue language outside of Sublime Text.

[davexunit]

Sure, but keep in mind that Guile is also a general-purpose programming language and a virtual machine for running languages beyond Scheme, such as Emacs Lisp. I do web, game, and systems programming with Guile and it does a good job at all of them.

[electroly]

Lua did. Python isn't commonly used in situations where you'd consider embedding Guile.

[samwestdev]

SONIC BOOM