
GNU Guile beta 2.1.3 released - weeber
https://lists.gnu.org/archive/html/guile-user/2016-06/msg00058.html
======
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](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).

~~~
mwcampbell
The global complexity would be lower if the mbox format, which IIUC is what
makes that quoting necessary, would just die already. We've only had Maildir
for about 20 years now.

~~~
jjnoakes
Maybe, maybe not.

There's quoting everywhere. EVERYWHERE. Doing it wrong is the source of some
extremely damaging exploits (SQL injection, shell command injection, XSS,
...).

Fixing From and >From is but a drop in the bucket.

------
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.

~~~
omni
I may be mischaracterizing here, but weavejester is known for ubiquitous
developer-facing stuff such as compojure and hiccup while swannodette is by
far the #1 contributor to the ClojureScript compiler. They're both great
contributors to the community, but I wouldn't fault David Nolen for compiler
code being less intuitive than framework code.

~~~
DigitalJack
Oh I didn't mean to imply fault, other than my own. David is awesome, and on a
completely different plane than me, so I struggle with things that are obvious
to him.

------
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.

~~~
coldtea
Errr, what?

Python is the clear winner in the scientific computing space.

~~~
PeCaN
That… isn't an "application extension language" use case. I guess if you count
wrapping various C and Fortran libraries it's a "glue" language, but that's
not exactly what I was getting at.

~~~
coldtea
"Glue code" is not just (or particularly) about "application extension" (e.g.
as embedded Lua in game engines).

Traditional "glue" has been called any language that connects between
different programs and systems (e.g. take data out of system X as CSV,
preprocess them, input them it program Y, do something with the results etc.

Which Python is used for a lot, in the scientific (physics and biology at
least) communities. And yes, wrapping C, fortran etc libs too.

------
samwestdev
SONIC BOOM

