

Lisp after Python after Lisp - thepanister
http://devlog.bigmonachus.org/2009/03/lisp-after-python-after-lisp.html

======
danprager
Learning Scheme helped my Python by teaching me some new (to me) idioms,
besides the first-class function stuff.

For example, it is natural in Scheme to declare a lot of local information,
including local function definitions. These have the great advantage of
knowing about variables within the local environment. So rather than declaring
an external function with heaps of parameters to pass in local state, you just
declare a local function which automatically gets access to the variables in
the surrounding scope.

The same idiom works neatly in Python too, but didn't occur to me previously.

* * *

Also after learning Python and Scheme, Ruby felt a bit like a cross between
the two, and quite comfortable.

~~~
jamongkad
What do you mean by this? Is this the same method of declaring inner functions
within the scope of the outer function?

~~~
danprager
Yes, in that case the inner function has access to the arguments of the outer
function. But you can go deeper -- e.g. declaring an inner function inside
code inside the out er function -- which also knows about the local variables
in the outer function.

Or if you're only doing it once use a lambda (with the same advantages).

~~~
jamongkad
Isn't this how you use closures? I think I've been doing this with my
javascript code without even noticing it. :-)

~~~
danprager
Yes, these idioms would work in Javascript too.

I guess the point is that people are starting to discover that languages like
Python and JS support these functional idioms quite nicely.

Remember when all the books on JS pretended that it was some kind of crippled
cousin of Java (as the name suggests), rather than a Scheme-lite in Java-esque
syntax (as its designer has opined).

~~~
jamongkad
Haha yes, I do remember those times. Now that you've mentioned it another
language that fits the description of a Scheme-lite in Java-esque syntax is
Lua.

------
jimbokun
"I don't know if there are programmers out there whose pseudo-language is
functional. Maybe it's just human nature to think imperatively."

A lot of time it just kills me that "if" statements don't default to returning
the true branch or false branch. You need the ternary conditional operator in
Java and other C-derivatives, and in Python you need to resort to some hack
with and/or precedence.

I'm also wondering if I should declare all variables final in Java, and only
change that default if I really, really have to.

~~~
bk
I guess that's why Ruby has been called an "acceptable lisp". I take
"everything is an expression" so for granted by now, and it makes for
beautiful, terse code.

The non-working python if statement/assignment example from the article works
perfectly fine in Ruby. (No python/ruby flamewar please, that's really not the
point)

~~~
arohner
How about a ruby/lisp flamewar? :-) J/K.

In all seriousness though, I've recently moved to Clojure from Ruby. I'm not
looking back. Clojure is significantly cleaner, faster, and has better
libraries than Ruby.

