[mtlmtlmtlmtl]

They're not. But they're also not required to flaunt their own ignorance as though it's a well-formed opinion. Also, in a professional setting, I find it a bit unprofessional and rude to poo poo technical ideas over trivialities.

[alex_lav]

> But they're also not required to flaunt their own ignorance as though it's a well-formed opinion.

I don’t like the parenthesis. I’m not flaunting anything. Is it “flaunting” to calmly and respectfully share an opinion? To you it’s trivial, to me it’s not.

It seems like you’re interested in creating conflict with people that don’t like a thing that you like. Which, I would cast this behavior as unprofessional, tbh.

[CooCooCaCha]

I'm not a fan of the parenthesis either, but when I learned about s-expressions and how lisp programs are also a data structures that piqued my interest and helped me look past them.

I question people's judgement who can't look past the syntax when there is a very good, and interesting technical reason behind them.

[arnsholt]

Code as data is interesting, but mostly orthogonal to S expressions. For example, Prolog code has the same property without S expressions, and more esoterically TeX (which is succinctly explained to a lisper as programming with defmacro but not defun).

[mtlmtlmtlmtl]

Also raw machine code and XML, even.

Though it's just more powerful in Lisp precisely because the code is just lists in a language designed around working with lists.

So you can actually leverage this property in Lisp without the code becoming inscrutable for it, which in my experience doesn't usually happen in other languages.

[alex_lav]

> I question people's judgement who can't look past the syntax when there is a very good, and interesting technical reason behind them

The list of things that are interesting is endless, though. I see something I’m turned off by, I move on. There are plenty of valuable things to spend time on.

[adastra22]

A-expressions are a choice, and it is fine to argue whether it is a good one. There are plenty of other ways of achieving honiconic syntax.

[ColonelPhantom]

What's an A-expression? I tried looking it up but didn't find anything.

I have heard of M-expressions but never of an actual implementation. Scheme also seems to have some SRFIs involving alternate syntax that's whitespace dependent, like SRFI 119 (wisp), SRFI 110 (sweet-expressions or T-expressions), or SRFI 49.

[adastra22]

A mistype of S-expression that is outside the edit window.

[Munksgaard]

I don't like curly braces, but I don't let that decide which programming languages I use.

[alex_lav]

That’s your choice!

[hautcake]

People that express strong opinions about syntax come across as dummies to professionals. Doesn’t mean they are of course. Just sayin’.

[alex_lav]

Similarly, people that dismiss valid criticism because it doesn't match their personal opinions seem like dummies to grown ups.

Unsure if it means they are or are not dummies, though.

[dun44]

Imagine someone who hates the exponentiation operator but wants to do mathematics nevertheless. For a living.

[alex_lav]

Interesting hyperbole.

[adastra22]

I’ve written a large application in Lisp. Hated parentheses before, hate them even more now. It needlessly obscures code.

Maybe it’s a personal issue, idk. But it’s not out of ignorance nor is code readability a trivial point.

[tmtvl]

Yeah it is a personal issue, there are people who really like Lisp syntax (I'm one of them). That doesn't mean anything bad, of course, some people like dark text on a light background, others light text on a dark background. Everyone is different and that's what makes the world so awesome.

I see something like:

  some-var: I64 := a * b - c ^ d ^ e;

...and my brain gives out, while I find:

  (let ((some-var (- (* a b)
                     (^ c d e))))
    (declare (type I64 some-var))
    ...)

...to be much more readable, YMMV.

[adastra22]

How do you look at the latter and know the code structure? Are you counting parentheses? Or are you relying on conventions around white space indentation. If the latter, are you not concerned a misplaced parentheses might make the code different from it appears? There could be bugs not shown in the indentation.

Most lispers I know code in eMacs or other smart editors that provide auto code formatting and colored parens. But why not just make the indentation (or whatever that you really rely upon) the actual syntax, so there CANNOT be hidden bugs of that sort?

Edit: to expand on this, I think it is no coincidence that most lisps remain untyped to this day. Strong typing is about having the compiler enforce type rules so you the developer can’t fuck it up. Weak typing is more convenient, but ultimately a source of bugs. Lisp has, effectively, weak syntax. I don’t like weak syntax for the same reasons I don’t like weak typing.

[dreamcompiler]

> But why not just make the indentation (or whatever that you really rely upon) the actual syntax, so there CANNOT be hidden bugs of that sort?

That's Python. When whitespace matters, any aesthetic reformatting mistake can change the program's meaning. With s-expressions this cannot happen. A lisp code parser is completely deterministic regardless of where the newlines, spaces, and tabs occur. You can remove all the newlines from a 10,000-line Lisp program and the compiler will parse it exactly the same as if it were formatted aesthetically.* You can also write a simple program that takes that godawful one-line program and reformats it aesthetically however you like--the meaning won't change.

IOW in Lisp the aesthetics of the source code do not determine its meaning; aesthetics and meaning are orthogonal properties and you are free to adjust the two independently. This is also somewhat true in languages like C, but rather than several special-case punctuation characters, in Lisp there's only one: The parenthesis. Lisp is thus similar in spirit to HTML where semantics and layout are [mostly] independent.

* With a few obvious exceptions like EOL comments, and newlines that are part of quoted strings.

[xigoi]

> any aesthetic reformatting mistake can change the program's meaning.

Why would you just randomly change indentation? On the contrary, I don't want the indentation to say something else than the code actually does.

> You can remove all the newlines from a 10,000-line Lisp program and the compiler will parse it exactly the same as if it were formatted aesthetically.

But a human won’t. And that’s a problem.

[lispm]

> Why would you just randomly change indentation? On the contrary, I don't want the indentation to say something else than the code actually does.

Because the user may want the development environment to display snippets of code in various places: REPL, debugger, code browsers, inspectors, various editor types, ...

In a Lisp system the code can be data and text. Code formatters can reformat code depending on user preferences, device types (color, font, ...), view sizes, ...

In Lisp often code gets generated (for example via 'Macros') and this code will be automatically layouted in various view (different widths, different fonts, different detail). Code can be small or large, the system may abbreviate parts, which one can expand, if necessary.

Source Code is not necessary static text in a file system. Code can just be list-based data structures and layout is fluid.

In Common Lisp the formatted output of code is also user extensible/customizable, a 'pretty printer' is a part of the language spec:

https://www.lispworks.com/documentation/HyperSpec/Body/22_ba...

If we read a text in a book reading the device, one can also change for example font size and the thing will relayout the text accordingly.

[vindarel]

Use an editor that auto-inserts parens and that indents the code correctly. Now nothing bad can happen. And the parens are used to edit code structurally.

re typing: Coalton brings Haskell-like typing on top of CL. https://github.com/coalton-lang/coalton/ Other lisps are typed: typed racket, Carp… and btw, SBCL's compiler brings some welcome type warnings and errors (unlike Python, for instance).

[tmtvl]

Well I don't like indentation-based syntax because when I write code with such syntax down in a notebook I have this bad tendency to drift to the right as I go lower down the page. And then if I go training or something and return the drift causes me to lose the structure of the code.

With round brackets on the other hand, well... I think my brain just works with round brackets. Like my mind is coded in Lisp or something, I dunno. It would explain why I'm so slow: GC pauses. My mind should really be ported to SBCL or something.

[Kinrany]

Auto code formatting is a must in every language at this point.

[frankjr]

I think you've just accidentally demonstrated why most people don't like Lisp syntax.

[mtlmtlmtlmtl]

You're clearly the exception though. It's almost always just ignorance in my experience. That's why I used the word probably. I assume if someone asked you what you thought about Lisp, you'd have a lot more interesting stuff to say than just "ew, parentheses", right?

That's my point, is all.

As for readability, I don't think it's trivial at all. I just don't think syntax has all that much to do with it. It plays a role, but a very minor one compared to overall code quality. In other words it's syntax that's mostly a trivial point, not readablity.

One undeniable advantage of Lisp in terms of syntactic readability though is that other languages always end up piling on more syntax over time as the language gets older. That's by far my least favourite thing about Rust for instance, even though I do love the language. There's always some new syntax, keyword, or position that an existing keyword can suddenly go in. The longer I go without actively using Rust, the more work it is to start again, because I have to go learn all this new stuff now. And syntax always takes a while to feel intuitive, at least for me. But it's still a lot easier than grokking new semantics and paradigms. I still don't have a good handle on async rust.

If someone told me to go read some ALGOL 68, I could probably do just fine because there's nothing semantically unfamiliar about it compared to something like C. But if someone gave me some Haskell written as sexps I would be utterly lost despite the syntax being perfectly comfortable to me. Because I never quite grokked typed FP.

[adastra22]

No, the horrible syntax of lisp is pretty much all I have to say on it, honestly. I don’t care for lisp for the same reason I don’t care for perl: write-only languages are a bigger hinderence to software maintenance than whatever advantage might be obtained. And the advantages of lisp have long since been obtained by other languages.

[DonaldPShimoda]

> write-only languages

Lisps are not write-only. They're easy to read precisely because there is no inscrutable syntax. Every pair of parentheses has a first element, which tells you what they're doing. The parentheses denote a scope in which to look for arguments.

Conventional style guides also make the readability practically a trivial issue because you end up indenting arguments such that the structure of the program is reflected in the indentation, because each S-expression within a parenthesized S-expression is itself an AST node. Writing readable Lisp is just a matter of reflecting the AST's structure in the indentation, which most people do in other languages anyway (to some degree).

> the advantages of lisp have long since been obtained by other languages.

Clearly not, since most other languages are still not S-expression-based. (Though, admittedly, some other advantages have been copied in other languages.)