Hacker News Reader

Comment by overcast | Hacker News Reader

I respect it's usefulness, but the LISP syntax just never worked for me. (((())))))()()))(()))())) is not something I want to read and write all day.

View on HN

Have you actually tried it for a significant period of time?

Most (but not all) people who have used lisp for significant projects find that they either like the parens or are simply neutral about them.

There are very few people I have heard from that have stuck through a significant project in lisp and came out hating the parens still.

Admittedly, I've not used it for any significant period of time. But I do base a lot of language learning on the ease of use of its syntax for newcomers. Having to force my way through a significant project with it, just to potentially enjoy it, keeps it at the bottom of the interest list.

> But I do base a lot of language learning on the ease of use of its syntax for newcomers.

From what I've observed of learners, people without lots of programming background seem to have no more problem with parens in lisps (in the broad sense -- mostly, I've seen this with Scheme and Racket) than with syntax features of various Algol-family (C, etc.) languages.

People with extensive experience in programming that is mostly restricted to Algol-family languages seem to be the people who are most put-off by lisps and their parens.

Which is to say, there are different kinds of newcomers.

I was referring to "newcomers", as just people new to LISP, and not complete newcomers to programming languages. So more the latter of what you wrote.

> I was referring to "newcomers", as just people new to LISP, and not complete newcomers to programming languages.

Sure, but not all newcomers to lisp that are familiar with programming are people that whose programming experience is tightly tied to Algol-family languages. For me, Lisp wasn't any more unwelcoming than any other new languages when I encountered it well into my experience with programming, but a number of languages I encountered much earlier in my programming life (BASIC, Forth, Logo, x86 ASM, among others) weren't Algol-family languages.

The fact is that there aren't actually more parens than most languages. Take a look at any JavaScript code base and you'll see far more parens there.

One benefit of Lisp syntax is that it provides you visual information about relationships in the code, since it's structured as tree. The nesting tells you how functions relate to each other at a glance. It makes the code easily scannable, once you're used to reading it.

Another big advantage is that you can use a structural editor with Lisp. You don't actually manage parens by hand, the editor does it for you. You can see it in action here. https://cursive-ide.com/userguide/paredit.html

The syntax is actually one of the easiest ones to learn, because there is very little of it and it's very consistent. Just because it's not familiar, doesn't mean it's hard to learn.

I use Clojure at work and I regularly train co-op students. I haven't had a student who took longer than a couple of weeks to become productive with the language, or didn't love using it. However, most had a negative reaction to the syntax initially.

Exactly this. I've actually never met a person who has used a lisp to build software and complained about parens. I have the feeling parens are like functional language syntax, just something foreign which seems annoying or pointless until you actually start using the tools for a significant time and learn the benefits that arise from what initially seemed strange and alien.

> Most (but not all) people who have used lisp for significant projects find that they either like the parens or are simply neutral about them.

There's a substantial selection bias there in that people who have strongly negative feelings about parens have plenty of opportunities in the field to work with languages without them, so the only people likely to put up with them on significant projects are ones who feel positively, neutrally, or perhaps only weakly negatively about the feature from the start.

That said, I do think the complaints about that particular feature are overblown, much the way those about Python's particular whitespace handling are.

I think this is related to the fact that our own internal parsers that have been trained upon c-style code falls about when trying to read list code. So the dislike is not due to the number of parenthesis, but rather our own internal discord when trying to apply our existing mental parsers.

The only way to get around this is to spend enough time using the language so that you can build a new mental parser.

I did quite a bit of Common Lisp coding back in the day and I never grew to like the syntax. I felt it was the price I had to pay for macros, but otherwise found it awkward.

Did you ever learn Paredit? Once I did, editing any other type of code became awkward in comparison.

When i was testing out clojure a few months back, it took me around 4 to 6 hours to get used to them. After that, my eyes where just ignoring them and the code looks very much like a C type syntax.

Really though, it's better to think that Lisp has no syntax, and that really you're writing your code directly in the parse tree that other languages compile-to. The parens are simply to define the boundaries of the trees.

And besides, with proper indentation, it becomes easy to read and easier on the eyes.

Give Parinfer a try!

https://shaunlebron.github.io/parinfer/

https://atom.io/packages/parinfer

Idiomatic Clojure tends to have fewer parenthesis than Java.

I also find that it tends to be more concise which lends to denser code. The density can be a bit off putting until you become accustom to reading it. The other part that is weird is having all of the closing parenthesis on a the last line. Consider the idiomatic way:

  (defn do_stuff
    [coll]
    (filter #(> % 10) (map Math/sqrt coll)))

  (defn do_stuff
    [coll]
    (filter #(> % 10) 
            (map Math/sqrt coll)
    )
  )

Even though this is the same code, if you are coming from a c-style background the latter is probably easier to read.

Lisp syntax is awesome. It is unfortunate that some people have trouble getting used to it. I wish we could all live in parentheses paradise.

It may be a hindrance for new-comers who use notepad(or some other editor that has no knowledge of LISP).

For everyone else, what parenthesis are you talking about? I don't even see them.

Reply on news.ycombinator.com