
I'm turning into a Lisp snob - bgray
http://briancarper.net/blog/im-turning-into-a-lisp-snob
======
wglb
I am (now) a lisp programmer and find myself boring many people to tears about
it. But perhaps I am first a language guy, and like to see new solutions to
problems. None give me the satisfaction that Lisp has (smalltalk was close,
however). But I like to see new well-designed languages and how well, or not,
they address the engineering challenges.

For example, turbo pascal was written during the time that I was writing a
pascal compiler. The Pascal standard was truly a harsh mistress, and turbo
pascal made a lot of very useful engineering choices to make a fast, very
useful compiler in a small environment. Anders went on to do C#, which itself
was a good engineering feat.

I watch with interest Clojure and the ecocsystem that it plugs into and it has
a REPL.

But it is a pragmatic fact of life that C is a very large force in the day-to-
day world, along with a tool used by serious hackers (c.f. Coders At Work).

Python is very nicely designed and gets you to a higher level of programming
with ease.

So I was curious when Go came along, as a language development observer, to
see what were they coming up with.

It is clearly a language that has had a lot of thought put into it and it
seems to be something that will challenge C on its own turf ultimately. Faster
than Python, and possibly ultimately approaching C in speed, it has some
useful new ideas. In particular, how it does goroutines and channels is quite
refreshing. It addresses the admonition that "threads won't work if they are
just libraries" with new language constructs.

So criticism of language ought to be tempered by some experience with the
language. Having done enough of them, it seems that I often don't have a full
appreciation for a language until I have done something significant in that
language. So I feel comfortable offering severe criticism of languages like
RPG-III and Fortran II and Altair Basic and Bliss-36.

I am probably to the point of being a lisp snob by now, but do appreciate the
finer points of other languages.

I think Go is a step in the right direction for the problem that it wants to
solve.

~~~
morphir
how can you say that C is challenged by Go? Go is built with C. This is true
with python as well - in being a C abstraction. C is well suited for the UNIX-
like programming, where you create efficient system libraries. With as little
abstraction as possible I might add.

------
barrkel
> "Programming language quality is usually inversely proportional to the
> number of special forms"

Programming language obscurity is also usually inversely proportional to the
number of special forms. Church numerals?

The happy place is somewhere in the middle, where there's enough language such
that you don't have to build it out of other pieces - and this also helps with
performance, static analysis, tooling, debugging and lots of other areas - but
there isn't so much that you end up with lots of methods to do the same thing,
in similar but incompatible ways.

~~~
shawndumas
Perfection is achieved, not when there is nothing more to add, but when there
is nothing left to take away. --Antoine de Saint Exupéry

~~~
mechanical_fish
And yet Antoine is famous for book-length works, not poetry, and certainly not
_minimalist_ poetry.

Don't take the lesson too literally. You can, in fact, take too much away. How
much you need to put in depends on your artistic goals and, of course, on your
audience.

~~~
Perceval

      so much depends
      upon
    
      a red wheel
      barrow
    
      glazed with rain
      water
    
      beside the white
      chickens.

~~~
klipt
Makes you think, until

you realize you don't even

have a wheelbarrow.

------
miloshh
"I could show these poor imperative programmers how their problems could be
solved much easier in Lisp if I wanted to." That to me (as an outsider) seems
to be the main message of these Lisp blogs. But at some point, nobody will
believe you could do it, unless you actually do.

~~~
maelstrom
Yes, if Lisp is so powerful, where are all the super programs written in it?
I'm only aware of EMACs and maybe at one point Autocad? And I guess PG wrote a
couple webapps with it....

~~~
mahmud
That's a logical fallacy. Something can be both great and unknown to you.
Usually, you seek information about things you know you need/want, and can
afford. If a topic does not interest you, you will forever remain oblivious to
it, except maybe for some tangential news about it that reach you by accident.

It's naive to think that just because you're a programmer you know everything
there is to know about the software industry. You don't. You know about a
small fraction of the _mainstream_ development _tools_ , and even those, at a
superficial level. For example, can you name the top software products for
running local elections? how about automating a chemistry research lab?
packages for oil exploration? vacation property management? real-time spoken
Chinese processing? computational archeology? artist talent management? threat
modeling for distributed corporate networks?

See? :-)

"Social" programmers, the guys you see in chat rooms and "community" websites
are all mostly generalists, and typically work in well defined roles as grunt
programmers. Nothing fancy, website here, a database there, a GUI or two,
click, generate, zip, distribute, and call it a day type work. Don't let this
closed echo-system define your perception of "the software industry".

~~~
maelstrom
There should at least be one canonical example. I'm not claiming to know
everything, I'm trying to fill in my knowledge. If lisp is so great, and so
much more productive, and used by the greatest programmers on Earth, point me
to some great code so I can become more informed.

Should I start reading EMACS source? Show me the code! If there's not at least
one great open source project written in lisp, I'm not inclined to take your
claims prima facie.

~~~
mahmud
Google "cliki" and "lisp success stories" in the future.

<http://maxima.sourceforge.net/screenshots.html>

<http://www.izware.com/mirai/index.htm>

------
kunley
OTOH the Go authors made it clear that it's intended to replace C for the
basic system programs & libs. I think that's step in the right direction.

I started to earn money using Erlang & Clojure, so looks like I'm not only fan
of new exciting high-level langs but also quite an adopter of them in the so-
called real world. Still there are some uses when a VM of your Chosen One
language brings an unacceptable overhead. Imagine your daily work using vi,
grep, find as they were compiled into jars and each running via JVM. Nightmare
with that 2 seconds delay of starting each little proggy, isn't it? (Have you
ever used the original Amazon's EC2 commandline tools written in Java? You'd
know what I mean).

Of course it could be solved by some kind of injecting of program to be run to
some VM already running, but that's not an established practice of working
with basic programs in your system. At some level fast binaries are needed.

Personally I think it's a pity that some language of SML family didn't get to
the mainsteam for such system programming. Haskell is fun and people write
things like text editors and window managers in it; but is still perceived as
too academic for real tasks which isn't completely true.

~~~
omouse
_I think that's step in the right direction._

Maybe for UNIX junkies. Other people would like to use languages that don't
suck and operating systems that aren't retarded.

~~~
gloob
Experimental evidence suggests that people want to use Visual Basic and
Windows, actually. Although the language stats may have changed since the last
time I looked at them, I'm reasonably certain at least Windows is still on
top. Make of that what you will.

Edit: For what it's worth, I have some sympathy for Microsoft's position. I
don't doubt that if they could just break away from backward compatibility
they could make something far less kludgy than what they have; unfortunately,
if they did break away from it, they'd lose an awful lot of money. Alas.

~~~
kunley
Erm, do people want to use VB for programming libraries and core system tools?
(I thought we're talking about such case, as Go authors clearly stated that's
their target).

Go competes rather with C/C++ than with VB or any Lisp.

C'mon guys, you don't have to bash any language or solution only because
somebody wants to use it for _some_ reason (which may be different than
yours).

Having Go in a toolchain traditionally reserved to gcc will only make things
better and will NOT threaten a position of your shiny new high level language.

I wish Go people success. They are smart hackers from the ol' days.

------
justinhj
"Ugh, look at all that syntax."

As a common lisp programmer it's sad to see somebody do to another language
what people do to CL. One superficial glance at the syntax and write it off,
without further criticism.

"Lisp has a lot of brackets, LOL"

~~~
briancarper
After living with a nice s-exp language, C-like syntax seems like it brings a
lot of problems with very few benefits. However I wouldn't dismiss a language
based only on the syntax.

------
fuentesjr
It seems you (as well as several other people) can only imagine a future with
Haskell or Lisp syntax as if anything else is inferior. I find that to be
foolish and immature.

Go was specifically designed to be a systems language, period. Lisp was never
designed as so, and perhaps that is why its hardly used as a systems language
today. Personally, I like Lisp, Haskell, and Python but I also know C is a
great systems language even though its not perfect and its a bit passed its
prime. Thus Go seems to be a good progression from the C/C++ family (I never
really saw Java being a systems language but that's my opinion).

Anyway, I agree I think you're becoming a bit of a lisp snob. It might suit
you to be a bit more open minded and objective. Even if you don't fully
understand the design of Go, you should be able to understand that it was
designed by people who have credible experience and skill in designing
languages and systems. And sorry to spoil things for you, but the last thing I
can imagine is Clojure being the next systems language.

Your post essentially is a brief comparison of a selection of fruits without
much substance.

Lastly, here's a piece of advice:

"That's why I reserve the right to match the language to the problem, and even
- often - to coordinate software written in several languages towards solving
a single problem."

~~~
ThinkWriteMute
GO is only marginally better than C, and that's not exactly saying a lot.

Modula-3? Now there was a good language :D

------
johnbender
"Sigh. (Programming language quality is usually inversely proportional to the
number of special forms.)"

I tend to agree with this, and I'm not a lisp fanatic.

------
tom_b
Snob or not, what increasingly pulls me to languages are the highly productive
DSLs that seem to fall out of them. For example, I need to deliver a few
lightweight web apps/services - and I stumble across Sinatra on Ruby (with a
little Sequel thrown in mixed with the oci8 oracle gem), which seems to do all
I need. My little ruby code snippets look just like that - snippets that are
short and expressive of the what I'm trying to do.

Lisp seems to be the "godfather" of these things and I'm more and more
interested in what makes _me_ productive, without being surrounded by a team
of enterprise programmers and all the boilerplate that seems to fall out of
other languages.

I make my living hacking SQL. What I'm really looking for there is the ability
to create a lambda on the fly for custom grouping (eg implementing a business
rule dynamically). I've worked on at least three big enterprise projects where
I could have eliminated thousands, if not tens of thousands of LOC with a
feature like that. Maybe I should punt and roll with a Prolog engine in the
Lisp of choice. Who knows.

I really enjoy the articles and comments on these topics here on HN. Keep 'em
coming.

------
intellectronica
If you're truly passionate about hacking it would be hard to avoid becoming a
LISP snob at some point in your development. But if you're pragmatic, you'd be
able to transfer what you've learned from LISP to other environments, that may
be better suitable for today's technological landscape. Is Google Go the way
to go? Only time will tell. But there's little you can usefully do with LISP
these days (unless the scope of the program you're working on is so restricted
that you really only need the language purely).

~~~
kmcgivney
Nice troll. Isn't Hacker News written in lisp?

EDIT: HN is written in Arc. You're saying that there's "little you can
usefully do with LISP" on a site which was written in lisp.

~~~
forensic
Even pg admits that Hacker News is a technology failure. HN is good because of
the community, not the software. The software in fact seems to be a hacked
together half-assed job.

~~~
pg
No, that's not true. The software works quite well, especially considering how
few lines of code it is. (To be able to say that was one of the goals for both
app and language.)

What I said was that it's not user features that keep people here. But there
is more to the software than user features. A good example is the code that
protects against various kinds of abuse, like spam, trolls, and voting rings.
By LOC that is a large percentage of the total, and HN as a community would be
long since dead without it.

------
caffeine
Go just strikes me as profoundly boring.

"Uh, we do lots of C. Yeah, and lots of Python. Dude. Let's make a language
that's like, uh ... C _and_ Python! Yes! Awesome."

In a world where the only thing harder than Haskell is Google's interview
questions, you'd think they would've come up with something more original.

------
alrex021
IMHO, he is not a snob. Realist would be a more apropriate term.

Just my 2c.

-lisp guy

------
andybak
I'm waiting for a Lisp dialect with significant white space. I think I've
turned into an anti-brackets-of-any-kind snob.

~~~
cema
Lisp programmers already tend to use the indentation the way adopted by
Python. Add more rules for indentation and newlining, and voila: all or almost
all parentheses become superfluous.

(But you need to really like white space!)

~~~
gloob
Brackets make macros easy, because they make the abstract syntax tree blatant.
Make it less blatant, and macros will become much more difficult to write.
Given the options of i) macros are easy to write, and ii) Python-style
indentation rules enforced by the interpreter/compiler, I'll take (i).

------
c00p3r
Those guys, who designed it were not amateur. The main goal is easiness to
code for average offshore programmer (hi, Java). Just name it 'C 2.0'.

~~~
mjgoins
Are you slamming the people of the island state of Java, or the programming
language, or both?

~~~
c00p3r
I'm telling you that _commercially_ successful hi-tech things in general, and
programming languages in particular, should be easy to use for average prople.
Java and especially PHP (which is a total mess which was never designed) are
the proof of concept. Note that both of them are using C-like syntax.

The biggest prof is, of course, the mobile phones market. Usability and
simplicity (along with simple visual effects) sell. And interface practices
and some widgets were adopted on the web.

And yes, Java (and Windows) was designed to use low-skilled labor. There is
nothing wrong with it.

~~~
whye
"And yes, Java (and Windows) was designed to use low-skilled labor."

This is an assertion I've seen repeated many times, but never with anything to
back it up. Do have any evidence for this, or is it just a feeling that you
have? Based on what I've read, Java was designed for use in embedded systems
like set top boxes, and the authors wanted to design away some common
developer errors. An evolutionary biologist might say that Java was "pre-
adapted" for use by low-skilled labor, but I don't think there is any
indication that it was designed for it.

~~~
c00p3r
_the authors wanted to design away some common developer errors_ , which
average developer cannot overcome.

There is no rocket science in memory management and pointer manipulation, but,
from commercial (manager's) point of view, those difficult to find and debug
memory issues is the common cause of troubles with schedule and budget,
because good programmers are rare, expensive and difficult to deal with, while
average code monkeys are cheap in the first place, and easy to hire and
replace.

That's why Java is the de-facto standard for corporate in-house development
(read - coding fabrics) and no one in that world even considers that stuff
like the ability (in theory) to run the same code on a different platform,
especially while it is impossible in so-called objective reality. (Just try to
run some bloated, poorly designed spring-hibernate-with-dependences project on
a platform other than x86).

And finally, consider RoR - same approach, same and big success.

~~~
whye
> the authors wanted to design away some common developer errors, which
> average developer cannot overcome.

Even the best programmers make mistakes. When writing for an embedded
platform, mistakes can be exponentially more costly and difficult to fix.

All I see is hand waving and misdirection, no facts. How disappointing.

~~~
c00p3r
If you didn't see any facts it not means that they does not exist. =)

