if does not evaluate

[Jacek Generowicz]

moughanj at tcd.ie (James Moughan) trolls:

> Lisp, I think, has two problems.  
> 
> Firstly an attitude among the community that actually *doing* anything
> is, well, beneath the language;

Investigate the links in the sidebar on the left on

   http://www.franz.com/success/

for a summary of the sort of stuff people actually *do* in Lisp.

If you actually bothered to look before posting unfounded rubbish, you
might have noticed that Lisp fans appreciate it exactly because it is
extremely good for writing industrial programs in real-world
situations.

> after working through two books and several university courses on
> Lisp, going from the definition of eval to lexical vs dynamic
> scoping to macros to continuations, I suddenly realised that I had
> no idea how to open a file or do basic string manipulation.  None of
> them condescended to sully themselves with such trivia.

Maybe Lisp (and therefore Lisp books) are designed for intelligent
people who want to solve hard problems, and it is assumed that
intelligent people can look up trivia like how to open files in the
language standard (); maybe books are considered necessary to teach
you the difficult things which you cannot read between the lines of
the standard.

Maybe you read the wrong books and go to the wrong universities, at
least for your sort of mind. The following book, still in the process
of being written, might be more to your liking:

   http://www.gigamonkeys.com/book/

Note the title: _Practical Common Lisp_.

> Secondly, Lisp's syntax doesn't parse well into the way people
> think,

... after 20 seconds of thought.

If you actually try using Lisp, as a programming language for writing
real-world programs, rather than as something to troll about, then you
will find that Lisp's syntax matches very closely the way people
think: they start thinking about source code as a tree structure
rather than a series of tokens. This takes us back to the original
point I made upthread. Just because your tools don't provide you with
the ability to do something, thereby ensuring that you don't do it,
does not mean that doing it is a bad idea, or that not being able to
do it is a language feature.

Lisp allows you to think of program source as a tree. "Source is a
series of tokens" languages seriously limit the way you think about
your program: this is a shortcoming, not a feature.

Don't conclude, just because the tools you use limit you in some way,
that escaping those limitations is somehow undesirable.