
Is Lisp still useful in today's world? (2011) - cpleppert
http://programmers.stackexchange.com/questions/55284/is-lisp-still-useful-in-todays-world-which-version-is-most-used
======
mindstab
Learning to program in lisp (specifically reading Practical Common Lisp
[<http://www.gigamonkeys.com/book/]>) has made me a better programmer in all
other languages even if I don't really use Lisp. Even my friends/coworkers
have noticed it when coding together. My style is forever improved.

Learning Lisp just seems to promote better ways of tackling programming
problems that is transferable to other languages where it's not as encouraged
naturally even if superior.

~~~
monkeyfacebag
Completely agree that learning functional programming has improved my thinking
and code. The one difficulty I continue to encounter is switching back and
forth between recursive and iterative thinking. From a computational
perspective they may be equivalent, but from a cognitive perspective they
aren't (at least in my case). I don't know how many times, for example, I've
been bitten by a stack overflow when jumping into Python from Haskell (or
equivalently, jumping directly into the ST Monad because I want to iterate
through some lists).

~~~
pavelludiq
I've been using Common Lisp for two years now, I've written exactly _ONE_
recursive function that wasn't an exercise or an example. Functional
interfaces to functions with local state in loops? What exactly is wrong with
that?

For example it is my opinion that this function is in no ways inferior to a
recursive equivalent:

    
    
      (defun range (end &key (start 0) (step 1))
        (loop for i from start to end by step
          collect i))

~~~
betterunix
Personally, I find that traversing data structures recursively is more
straightforward than iterative approaches, at least for most of the data
structures I deal with. This sort of thing, for example:

    
    
      (defun search (tree val)
         (cond
            ((null tree) nil)
            ((= (car tree) val) tree)
            ((< (car tree) val) (search (cadr tree) val))
            ((> (car tree) val) (search (cddr tree) val))
            )
         )
    

I write this sort of code all the time for more complicated structures;
iterative solutions would involve keeping track of a bunch of local variables,
which only makes the code more difficult to deal with.

~~~
baddox
The Little Schemer is the book that got me thinking about data structures
recursively (starting with linked lists), and that was later furthered by
SICP.

[http://www.amazon.com/Little-Schemer-Daniel-P-
Friedman/dp/02...](http://www.amazon.com/Little-Schemer-Daniel-P-
Friedman/dp/0262560992)

<http://mitpress.mit.edu/sicp/full-text/book/book.html>

------
duaneb
THe only thing that really distinguishes lisp these days (IMHO) is its macros.
However, I think there are better languages out there to learn any particular
paradigm-Python/Java for OO, Haskell/Erlang for functional, C for procedural,
Ruby/Python for dynamic & duck typing, etc.

Lisp is great if you need a compiler tomorrow. If you have the time, though, I
think that other languages are better when there's more time to invest.

EDIT: To actually answer the question, of course it's still relevant and
useful, but perhaps other languages have caught up. It's still used in
industry (Google uses it via ITA, IIRC).

~~~
pjungwir
I'm not a Lisp guy, but the amazing thing I see in Lisp that is missing from
other languages is that due to the extremely simple syntax, code is data and
data is code. That lets you do some amazing things (Cf. SICP).

On the other hand, isn't one lesson from modern computing that treating data
as code is really dangerous? I have yet to see this addressed by Lisp
advocates.

~~~
pavelludiq
Define dangerous? Are you concerned with security? In which case, don't eval
untrusted code, and you're fine.

Maintainability? If done right "code is data" could improve the
maintainability, or decrease it drastically, just like any other feature. If
you have 80 lines of comments for every 10 lines of code, you've decreased
your maintainability, comments are dangerous by that logic.

~~~
pjungwir
Yes, by "dangerous" I mean prone to security exploits. I've got nothing
against Lisp--I think it's a beautiful language, and I've dabbled in CL,
Scheme, and Clojure--but whenever I hear about using data as code I get a
warning tingle in the back of my head. One of the lessons of the recent Ruby
YAML debacle is that an executable data format will get used for untrusted
input eventually somewhere or other. (Edit: For example I can totally imagine
the digital circuits simulator from SICP 3.3.4 saving/reading Lisp code as an
input document.)

Maybe the power of Lisp's data-as-code is worth the risk. We don't stop using
string concatenation because of SQL injection. It's just that I've never even
read so much as a warning about this feature, and I'm curious what Lisp users
have to say about it.

~~~
pavelludiq

      eval("dangerous python code here")
    

As I pointed out, it is a problem in any language that has eval. The way you
deal with it, is you never eval anything untrusted, which is actually
extremely easy to do. I don't believe I've ever used eval ever.

In CL specifically, because the reader can evaluate code as well, every time
you use the read function, you should know these two things: 1) never use it
for user input. 2) bind _read-eval_ to nil. You'll be fine, or more
accurately, no worse than anybody else :)

On the other hand macros, and having a json style serialization format that is
much more powerful and actually extensible is a big plus :)

~~~
sdkmvx
Is it actually dangerous to use read for user input?

    
    
        (defun read-data ()
          (let ((data (let ((*read-eval* 'nil)) (read))))
            (mapcar
             (lambda (x) (format 't "~a: ~a~%" (car x) (cdr x)))
             data)))
    

Then I can

    
    
        (read-data)
        (("a" . 1) ("b" . 2) ("c" . (funcall (lambda () (princ "I ran code!")))))
    

And the following will print.

    
    
        a: 1
        b: 2
        c: (FUNCALL (LAMBDA () (PRINC I ran code!)))
    

But of course unless I eval the code, arbitrary code will not run (assuming I
haven't forgotten some aspect of the reader).

------
richeyrw
Is Plato still useful in today's world? I think if you answer that then you
should be able to give a a minimum a qualified "yes" to the question about
Lisp.

~~~
IvyMike
I was introduced to both Lisp and PLATO in 1992 at UIUC. I was very confused
by statement until I realized you meant Plato, not PLATO, which has very
little use in today's world.

<https://en.wikipedia.org/wiki/PLATO_(computer_system)>

------
base698
If you are a JavaScript, Ruby, Python programmer it will teach you where
first, rest, map, reduce, partial, apply, and a slew of other methods came and
what functional programming is. It also has the side effect of teaching you
how machines work at a low level (if you follow the SICP) with "environments"
and frames. If you are a Java or .NET developer you'll pick up functional
techniques and understand the origins of the object model. That's not even
getting into macros, which basically are runtime code that writes code. I'm
not aware of another language that has lisp style macros.

Ultimately it will help you be a better programmer even if you don't at first
see the benefit.

------
gre
* Most raw code written

So there are 20,000+ red-black binary tree implementations in Scheme. Great?

------
graycat
Sorry, but my view of what is really "useful in today's world" is what the
language has that makes it easy to get at, i.e., make use of, other software,
e.g., TCP/IP, device drivers, operating system services, authentication
services, APIs, something old written in Algol, Cobol, Folderol, Fortran,
C/C++, etc.

Actually there is a theme that a language can be interpretive and, really,
still fast enough if mostly it is used just as thin glue to connect other,
efficient software where nearly all the time goes. E.g., IBM's in-house
mainframes on their VNET were long run heavily with just their interpretive
language Rexx: VNET was a little like the Internet except the network was less
smart and the computers also played the role of routers. At one time IBM had
3600 such mainframes around the world. I've been using Rexx on Windows as a
scripting language and want to convert to PowerShell due to the better access
to Windows services.

------
rdmckenzie
Speaking as a Lisper, I have to admit that this is an open question for me. On
the one hand, the needs of parallel systems and state management offered by
functional languages stands to bring Lisps (Clojure, Common Lisp etc) and
other languages like Erlang ever more attention as we programmers attempt to
manage the complexities of multicore design and distributed systems.

As a systems programming language I think that lisp has utterly failed. The
Lisp machines are dead for various reasons (which I'm researching right now as
a side-project) and to the best of my knowledge compiled lisp has clearly not
taken the place of C in building operating systems (although I hope to do
exactly that as does the author of [<http://www.loper-os.org/]>).

All of this comes down to an individual's definition of utility. Lisp is by
definition of Turing Completeness just as capable as any other language you
may wish to name, but with the usual Turing Tarpit or small language warning
that you may have to roll your own. My perception, and one which several posts
here on HN has affirmed is that traditionally Lisp was used by lone AI
researchers who needed the power to roll their own anything quickly and
efficiently. As a result of this "roll my own" mentality and simple lack of
the internet (it was early and mid 1980s or so) libraries and SDKs as we know
them were never built for Lisp systems.

Another difficulty is that as several other comments note there is no "one
true" standard for Lisp. There is Scheme (which has official specs), there is
ANSI Common Lisp which is a spec upon which several implementations have been
based, and then there are countless other DIY and nonstandard lisps which
elect to use different function names and otherwise make code non-trivially
portable between lisp implementations. Not having a clear standard didn't help
the lack of a library ecosystem at all, but some dialects such as Common Lisp
and Clojure seem to be developing workable community library ecosystems. Of
late Common Lisp has grown a library structure via ASDF code loading tool and
the Quicklisp package manager, but Clojure is the only lisp I've ever
encountered that really made any effort at all in the direction of providing
native support for packaged libraries. The Clojure language includes syntax
designed for allowing one file to explicitly state and "require" code in other
files or even other libraries: a feature which is lacking from the Common Lisp
standard. Thanks to technomancy's Leiningen tool and the clojars repository
Clojure has a user-created system similar to Quicklisp + ASDF but trading
ASDF's search path idiosyncrasies for a search path structure which should be
familiar (or at least unsurprising) to Java developers.

TL;DR / Conclusion

If your boss comes to you and asks you to write a webpage, Lisp is probably
not what you turn to. Could you? Sure, <shamelessplug> my blog is built in
Clojure [<http://arrdem.com>].</shamelessplug> [<http://refheap.com>] is built
in Clojure. [<http://www.chris-granger.com/>] is (presumably) Clojure. I know
I've seen blogs in Common Lisp and other dialects but URLs escape me. Your
boss says "Access the database", there are Clojure (okay fine Java but there
is no real difference) libraries for SQL, MongoDB, Cassandra and more. Common
Lisp also has SQL and MongoDB libraries. In short, while there is value in
Lisp it is (for the time) not practically greater than the value of any other
language despite the elegance of the functional approach and the power of the
macro system. Hence its failure thus far to take over the world. However that
same value proposition is improving as the CL and Clojure communities create
and publish ever more libraries leading me to hope that Lisp may indeed take
over the world one day.

------
dschiptsov
This. Very. Site.

~~~
chc
I'm not so sure that's a good example. It seems to me that PG had a Lisp he'd
created for his own gratification and Hacker News was a good chance to try it
out in the real world. It's hard to imagine Hacker News would have suffered if
Arc hadn't been ready yet and he'd been forced to use Django or something. I
think HN helped Arc more than vice-versa.

~~~
nialo
PG says in several of the Arc essays that HN exists because he found that
programming languages turned out better when their creators worked on the
language and some problem being solved in that language together. HN exists
because he needed an application to force Arc to be better.

