
The German School of Lisp ("Fluchtpunkt Lisps") - cemerick
http://blog.fogus.me/2011/05/03/the-german-school-of-lisp-2/
======
IsaacL
Interesting article, introduced me to a whole bunch of lisps I had no idea
existed.

Slightly tangentially, can anyone explain to me what the supposed advantage of
using Lisp is over languages such as Python and Ruby (which also provide
functional programming, dynamic typing, etc)? I certainly feel that I'm more
productive in some languages than others, eg, I can do the same things faster
in Ruby than in Java. When I tried working in Clojure for a few mini projects,
I enjoyed using it, but didn't feel any more productive than in Ruby.

I actually like the Lisp-like syntax, but I usually find myself either a)
tying myself in knots trying to avoid the use of variables, or b) missing
Ruby's object system. It seems like these might be problems that stem from
inexperience, can anyone else comment? Is it worth reading "On Lisp" or SICP
to learn how to take advantage of Lisp's unique features (macros and so on)?

~~~
tdrgabi
It depends who you ask. I'm also a beginner in lisp. Wrote some hobby projects
in it but it felt like swimming against the current.

lisp appeared a long time ago, when non lisp languages were really primitive.
So a lot of the arguments you might read on the net might be outdated
(comparing it to C or FORTRAN).

Ruby and Python give you a lot of power that a lisp language has. I guess the
only thing that lisp has, which the other languages don't, is the "macro".
Which (in my opinion) is like a lisp "program" running before your lisp get
compiled and changes the code. So several lines can be expanded to lots of
dynamically generated code.

C guys will say they have #define & such, but this is a "program" with most of
lisp syntax not just some primitive ifdefs. So you can do a lot of advanced
stuff.

On the other side, python & ruby have a lot more libraries. I see that common
lisp has picked up steam again, with stuff like quicklisp which can be seen as
"ruby gem".

So to sum it up, lisp is a powerful language, it has constructs which are
still not available in other languages but you don't get the free stuff you
would have in big communities as python or ruby.

~~~
agentultra
Lisp has a lot more than just macros (also you might want to learn more about
macros; your definition is a little off).

You also get CLOS; which is huge. Multi-methods. Generic functions. MOP. OO
programming without generic functions is a huge pain for me now. It's a
completely different world-view that lacks very artificial design patterns.
You don't need a lot of the GoF design patterns because they're completely
abstracted out by the language of CLOS.

You get conditions and restarts. I hate exceptions! You lose the entire stack
and state of your application. It is next to impossible to recover from that
and restart the failed computation using exceptions. You could emulate this in
other languages... but it's already a part of the Common Lisp language itself.
No code to write or libraries to import to make it happen.

And only tangentially related to the CL language itself, SLIME is another
reason why programming with Lisp is a lot of fun.

 _So to sum it up, lisp is a powerful language, it has constructs which are
still not available in other languages but you don't get the free stuff you
would have in big communities as python or ruby._

You don't get anything for free.

~~~
tdrgabi
I agree that my macros explanation was stretched. I simplified it too much.

Restarts are really nice, I first heard about them in "Practical Common Lisp"
google talk: <http://www.youtube.com/watch?v=VeAdryYZ7ak>

------
mmphosis
<https://github.com/fogus/lithp>

<http://picolisp.com/5000/-2.html>

<http://mumble.net/~jar/tproject/>

<http://www.lambdassociates.org/Lib/libraries.htm>

<http://www.newlisp.org/>

<http://www.paulgraham.com/arc.html>

<http://sites.google.com/site/waspvm/>

Fluchtpunkt Lisps are…

Focused: Uncompromising in their vision

Spartan: Devoid of the seemingly unnecessary comforts found in many modern
languages

Controversial: Not always by design, but often because of their design

Fun

------
mark_l_watson
I just retweeted Michael's tweet link this blog entry - this is really a very
good classification of Lisp systems! It could be a potential time sink
however, trying more implementations :-)

------
drblast
This is very cool; I wasn't aware of the existence of some of these
implementations.

The Wasp Lisp is an interesting idea and looks like it has many of the same
benefits as Erlang. If I had to guess at what programming languages would look
like in the future I'd say they'd at least include capability to (easily) do
distributed computation like this, even if they're not based around the
concept.

There are so many qualities that Lisp has, like its lack of syntax, that makes
exploring new ideas very easy.

------
Kototama
I just spent a few hours searching but can't find a Lisp for Arduino. Does
anyone know a Lisp for Arduino or a Lisp that could produces C code small
enough (<32K) for it?

After some tries neither Chicken scheme nor Pico Lisp qualifies and PicoBit
does not seem to support the Arduino architecture.

~~~
nottwo
The small (2K) RAM size is the limiting factor, not so much the code space.

You'll find a few more options if you look beyond the atmega328 in the
Arduino: 'avr lisp', 'avr scheme'

The Lisps I've seen targeting AVRs have all used the atmega128 with 4KB of RAM
and they still use external memory of some sort.

Scrying (w/ 64KB external RAM):
<http://scrying.org/doku.php?id=scrying:interpreter_notes>

ActorNet (w/ 512KB external serial flash as virtual memory):
<http://osl.cs.uiuc.edu/nest/ActorNet-1.1.tar.gz>
<http://osl.cs.uiuc.edu/docs/actornet/kwonActorNet.pdf>

Femto microlisp <http://code.google.com/p/robobuilderlib/wiki/Femto>

For my own REPL-fun on AVR microcontrollers, I've gone with amforth:
<http://amforth.sourceforge.net>

