
Guile also supports the web at the programming language level - fogus
http://wingolog.org/archives/2010/12/17/on-the-new-posix
======
srean
I am really impressed by the level of activity in the Guile source tree. A lot
has happened over the last few years. I came back to Guile 1.9 from Guile 1.6
and the difference in speed was significant.

------
Zak
Some might find it ironic that a dynamically-typed language is advocating
typing as the solution to bugs. Of course, Lisp has a history of strong
runtime typing, and this looks like a good approach to the problem.

~~~
pjscott
One of the things I've always liked about Common Lisp is that you can add type
annotations, and the good compilers will try to propagate that information, to
speed up the program and to catch bugs at compile-time. If I declare a
variable to be of type (integer 0 100), the compiler can try to stick that in
a single byte in memory, and/or do runtime checking to make sure nobody puts
something negative or greater than 100 into that value. And if I add two such
values together, it knows that the result is going to have the type (integer 0
200), even if I don't declare that.

It's nice: a type system that's there when you want it, and stays out of your
way. After being exposed to that, I've never really understood what the
static-vs-dynamic argument was about. To me, dynamic and static typing looks
like a several-dimensional continuum, and where a language falls on that
continuum is a matter of taste.

~~~
sedachv
Try programming in Haskell. Pretty much all other statically typed programming
languages (except ML etc.) get their type systems wrong because all types are
really (or <x> null). That's useless for doing type checking, which is why
there doesn't seem to be much of an advantage to static typing. Type classes
and Hindley-Milner inference make things really nice to use. But it's really
the lack of null that makes Haskell's type system actually useful for things
other than catching trivial type bugs.

~~~
srean

      because all types are really (or <x> null).
    

Did you miss a word there ? It happens to me all the time.

~~~
jamie_ca
Parse it as lisp.

It's haskell-type-system-speak for "If you declare something to be a String,
it really means String or null."

~~~
pjscott
The Haskell type for that would be "Maybe String". When you get a Maybe value,
the compiler gives an error if you don't deal with the possibility that the
value might be Nothing.

