

Convincing Programmers They Want To Use Lisp - gnosis
http://pschombe.wordpress.com/2006/04/07/convincing-programmers-they-want-to-use-lisp/

======
barrydahlberg
_And now no one can forget to close the file, plus it’s shorter as well. There
is no way to do this in a non Lisp language._

C# has the IDisposable + using construct for exactly this purpose. If you're
not happy with that you can write your own using a lambda, just like his
example...

    
    
      using (open file here)
      {
        // Do work here
      }
    
      WithNetFile(f => do work here);
    

Lisp is neat, this is not a great argument though.

~~~
js2
The _this_ the original author is referring to is macros, of which, with-net-
file is merely an example.

The author makes this clear later in the post: "Once you have caught the
programmer’s interest with simple macros show them some other cool things they
can do, like language extensions. Experienced programmers are always looking
for more control, and macros give it to them."

~~~
barrydahlberg
Yes, but he is giving this as an example of how to hook programmers into
learning Lisp. I'm all on board with the macros, but you have to do better
than this as an argument.

------
CJefferson
This "thing that can't be done in any other language" looks an awful lot like
RAII in C++.

For example I can write:

    
    
      {
        ifstream file("filename");
        ...
      } // file closed here automatically.
    

or

    
    
      {
        mutex_grab g(mutex);
        .....
      } // mutex automatically released here

~~~
stcredzero
In Smalltalk, it's just a normal function you can add to Filename:

    
    
        doWithStreamThenClose: aBlock 
            | fileStream |
            fileStream := self newReadWriteStream.
            ^[aBlock value: fileStream]
                ensure: [fileStream close]
    

This allows one to do:

    
    
        (Filename named: 'mypath/foo.dat')
            doWithStreamThenClose: [ :fileStream |
                 "do whatever you want with fileStream"
                 "it shall be closed"
            ].

------
chc
I don't get the feeling he's used anything besides Java. His technique that's
impossible in a non-Lisp language is the normal way of doing IO in Ruby, only
it doesn't take a macro.

------
mark_l_watson
"adoption of Lisp as a universal language" what a bad idea! I am occasionally
an enthusiastic Lisp programmer (and I wrote 2 Springer-Verlag Lisp books many
years ago), but I would never advocate that any Lisp be a universal
programming language.

For most programmers, they probably need at least either Java or C#, a
scripting language (Ruby, Perl, or Python), and a Lisp language (Clojure,
Common Lisp, or a Scheme implementation).

------
teilo
"There is no way to do this in a non Lisp language."

Wow.

Is it any wonder that you cannot convince someone to use Lisp, when you have
no idea what other languages actually have to offer?

Python 2.6 has a built-in "with" construct for this. Java, C#, earlier
versions of Python and (gasp!) VB have the try, catch, finally construct.
Offhand, I can't think of a language that can't do this, but I'm sure they
exist.

~~~
ScottBurson
No, you're conflating two features. He's not talking about `unwind-protect',
which he hasn't even used in his example (that would be the equivalent of
`try' ... `finally'). He's talking about the fact that in Lisp, you can make a
single abstraction that encapulates the entire pattern of opening the file
before doing something and closing it afterwards. This is not that common a
language feature, though it is catching on. Python's `with' was introduced in
2.5, which came out a few months after his post was written. Scala's
"automatic closures" (I would say "automatic lambdas") show another way to
provide this functionality, more general than Python's `with'; I think the
blogger can be forgiven for not having heard of Scala in 2006. Java has no
elegant way to do this.

~~~
teilo
Thank you. I appreciate the correction and clarification.

------
spartanfan10
Still not convinced. I find Lisp interesting and even bought The Scheme
Programming Language but can't convince myself it's more useful to me than
other languages. I have been told about the power of macros before though, so
to that chapter I go.

------
reedF211
This article is nothing other than language fanboyism and I am not sure what
it's doing on the front page of HN.

~~~
stcredzero
I've half a mind to start a wiki for programming language fanboy/troller
tropes. That way, we can just link to that.

