Lisp Lacks Visual Cues

I say the opposite. Lisp's regularity allows the qualities of the program itself to emerge visually. It's amazing how fine-tuned an intuition one develops after a while for code one's looking at when its structure isn't distorted by extraneous demands of the language. In Lisp, I find I am frequently (and often subliminally) processing visual cues to figure out what I'm looking at, prior to parsing what the text says, which is a slower thing to do.

Actually, you get the same effect in any language. You can tell a lot about, say, a Java program by printing it out, sticking the printout on a wall, and walking back 10 feet. But Lisp's regularity makes this effect richer, more powerful, and workable-with at much smaller scale.

Unfamiliarity reactions are not properties of the unfamiliar thing. When you walk into a space that is brighter or darker than what your eyes are used to, you can't see as well. This does not mean the space "lacks visual cues".

Clojure makes great strides in this area, by claiming for itself the reader macros for [] and {} in addition to (). [] is always used any time variable binding takes place, for example. It also more closely follows the JSONy conventions used by Python, Ruby and Javascript.

My (arc-like) lisp dialect has pervasive python-style keyword args, which I find makes code easier to read. See, for example, https://github.com/akkartik/wart/blob/master/063http-get.wts.... Tokens starting with a ':' are keyword args. Removing them doesn't change program behavior.

You don't have to use them, but I find inserting the odd keyword arg makes things much easier to read.

Mostly it's a matter of habit (it's the same for typefaces, btw).

After some time, I found syntax-colored Common Lisp (in SLIME) to be very readable, and I started to find confusing other languages.

c2.com is classic, or in other words: archaic, software. This makes the page hard to read in this case. For example, it seems to be written in the style of a discussion, by multiple people, but you never know who wrote what (there are a few signed comments, but most are not). There are also no sub-headings to help you navigate the page.

It (Lisp's "lack of visual cues") is also an interesting topic, and I think it would be especially interesting if you looked at this while comparing it to Haskell.

When reading Scheme code for Chicken Scheme packages I find myself thinking – “So this is why Lisp is unpopular, it really is the parentheses!”

I am not experienced reading Lisp code, but I find the many levels of indentation and the abundance of parentheses overwhelming. I don’t know if this is the case with Common Lisp code.

In Chicken Scheme however, parentheses are interchangable with other brackets – so you can add visual cues through your style if you don’t care much about portability.

Hm, I'm a lisp newbie but just had a little think about this (http://blog.timfarland.com/2011/05/12/lithp.html). I'd be happy just giving special forms short, mostly non-alphabetic names, and using a bit of matchfix sugar, looking something like:

  (def map 
    (-> |list f|
        (? (== list []) []
           // (: (f (. list)) (map (.. list) f)))))

Guess what, syntax sometimes actually helps readability. For example Python's "something[2:-2]" to remove the first and last to elements of a list or maybe characters of a string.

Lisp is the language, where you have to write the AST yourself instead of having a language-defined parser.

they're called brackets

The link title is my #1 complaint with Lisp. I think it has many strengths and it's homogeneity is a strength, but also it's biggest weakness. Not a showstopper, of course, but it is a turn-off for me esp when I consider cases like having to parachute in and understand a new codebase or maintain something I wrote years ago. Python, in comparison, gives more visual cues as to what's what. It has less power, but more readability.