4 ms·
> Python defines the lower bound on the code readability Ignoring ;... comments for a moment, if we squash a Lisp program into one line and remove all non-esse
by kazinator 8y ago
> Python defines the lower bound on the code readability
Ignoring ;... comments for a moment, if we squash a Lisp program into one line and remove all non-essential whitespace, it's possible to recover it into nicely formatted code by machine, more or less.
> TLDR: Lisps - Schemes, Racket, CL, PicoLisp, Emacs and TXR Lisps to name a few - can be used to write astonishingly readable and to-the-point code, but the languages do absolutely nothing to discourage using them to write the most unreadable mess under the heavens. As for the reasons for this - I've honestly no idea at all.
This view is unbalanced without noting that Javascript, Rust, C, Perl, Java, Scala, Go, Kotlin, ... and a large number of other languages, have the flexible formatting that allows for unreadable code. Ruby, anyone? https://github.com/mame/quine-relay/blob/master/QR.rb https://github.com/mame/quine-relay/blob/master/QR.rb
> As for the reasons for this - I've honestly no idea at all.
Bad formatting is a bug that is fixable in the actual code (greatly assisted by automation) and a minor social problem in programming that is treatable with education and experience. Therefore, it is nearly a non-issue.
- klibertp 8y agoYou're right, of course, on all points (BTW, WTF is with the downvotes??), but they are technicalities of interest to lispers. I omitted these because I wanted to present a convincing argument that fnord123 simply had bad luck and encountered bad Lisp code. And that there's a lot of good, readable code written in s-exps out there. The resistance to s-exps in the general population of programmers is bad "news" (if something 50 years old can be called that...) for Lisps. It's hard to fight it in general terms. Pointing out that C, JS, PERL, etc. are often much worse in terms of readability - while obviously true - doesn't really help in convincing someone to look at s-exps differently. This is why I chose Python for comparison and tried to present a positive argument, saying that you can write code "even more readable than Python at its best" in Lisp. I ignored automatic formatting because it's not part of the language, but of tooling. The problem with tooling is that not everyone uses it. I've had a "pleasure" of working with a 50+ kloc Clojure code base written mostly by C programmers who didn't know or care about formatting tools - honestly, it was a nightmare. Of course, each file could be automatically reformatted into something sensible, but the fact that it was written the way it was and the language did nothing to prevent that still stands. In Python, you at least would get the indentation right. Readability is a hard problem in general. You're right that it's also a matter of education in the community. You're right that it's almost negligible a problem for lispers themselves, as they know how to reformat the code automatically with a single key press. It is a problem, though, for people who come into contact with Lisp code for the first time. I wanted to convince fnord123 that it's not the syntax itself, but rather how it is used that's a problem - like with every other kind of syntax out there, by the way. I'd be extremely happy if he reconsidered and tried to read some of the better-written s-exps based code.
- kazinator 8y agoIn Lisp languages, we don't use pure S-exps for everything; we have notations. We have 'X instead of (quote X), `(,A ,@B) instead of (list* 'A B), and numerous # notations. In the area of arithmetic, although the basic operators are functions invoked using (f arg ...), we give them short names like +, -, * and /. Why? The obvious reason is that we would find it irksome to be writing (add ...) and (mul ...). Lisp can have notations, and they can be had without disturbing the Lisp syntax. Notations that are related to major program organization have payoff. In TXR Lisp there is relatively small set of new notations, which all have correspondence to S-exp forms, the same way that 'X corresponds to (quote x). ;; slot access obj.x.y.z --> (qref x y z) Of course, people are going to prefer this to something like: (slot-value (slot-value x 'y) 'z) Then: ;; unbound slot access .x.y.z --> (uref x y z) ;; method call obj.x.(f a b) --> (qref x (f a b)) ;; x.f(blah).g(foo).xyzzy(x, y) pattern: x.(f blah).(g foo).(xyzzy x y) ;; looks like this ;; sequence indexing, function calls (the "DWIM" operator) [array i] --> (dwim array i) [f x y] --> (dwim f x y) ;; ranges: a..b --> (rcons a b) ;; slice [str 0..3] --> [dwim str (rcons 0 3)] ;; Python-like negative indexing: [str -4..:] --> [dwim str (rcons -4 :)] ;; : means "default value: one index past end sequence (its length)". ;; quasistrings -- recently appeared JavaScript in strikingly similar form! `@a @b ...` --> (sys:quasi @a " " @b) --> (sys:quasi (sys:var a) " " (sys:var b)) ;; word list literals #"a b c" --> ("a" "b" "c") ;; quasi word list literals #`a @b c` --> (sys:quasilist `a` `@b` `c`) Some Lisp syntax is streamlined: (lambda (a b c : x y . r) ...) ;; a b c required, x y optional, r rest Dot notation allowed without preceding atom: (. x) -> x Improper lists can be function calls: ;; TXR: verbosity-free wrapping of a function. (defun wrapper (. args) (wrapped . args)) ;; CL: (defun wrapper (&rest args) (apply #'wrapped args)) This works even if the thing in the dot position is a symbol macro expanding to a compound form. The reason is that the code walker/expander will recognize and transform (func ... . rest) into (sys:apply (fun func) ... rest) first, and then expand macros. (I.e. we can't work this into existing Lisps like CL implementations without going down to that level.) ;; the : symbol -- symbol named "" in keyword package: ;; used as a "third boolean" in various places (func 1 2 : 4) ;; use default value for optional arg, pass 4 for the next one ;; diminishes need for keyword args ;; built-in regex syntax #/a.*b/ ;; C-like character escapes "\t blah \x1F3 ... \e[32a" ;; multi-line strings with leading whitespace control: "Four sc \ ore \ and seven years ago" -> "Four score and seven years ago" ;; Simple commenting-out of object with #; #; (this is commented out) Also, there is no programmable reader in TXR Lisp; no reader macros. I'm not a big fan of reader macros. They are only useful for winning "I can have any damn syntax in my language" arguments. Problem is, the whole territory of "any damn syntax" is a wasteland of bad syntax, nt to mention mutually incompatible syntax.