4 ms·
>Fractals are really cool to look at, but they're murder for navigation purposes. Are they? They imply that the structure is self-similar, which is a good trai
by coldtea 7y ago
>Fractals are really cool to look at, but they're murder for navigation purposes.
Are they? They imply that the structure is self-similar, which is a good trait for a structure, and makes it easy to read it at any level and get what's going on.
That's what trees are, lists of lists are, strings of characters are, etc.
>But if everything is self-similar top to bottom, there are no landmarks.
The specific functions called at each level are the landmarks.
- hinkley 7y agoWhat specific functions? That's my point. If you go all in on recursive design, all the functions, variables, and object names are the same all the way up and down your graph. There are no specific functions. It's all grey goo.
- thom 7y agoForgive my failing imagination, but can you give some concrete examples of what you’re describing?
- tabtab 7y agoI cannot speak for the others here, but with languages like say JavaScript, the symbols usually represent something. {...} will usually represent a block of code. "[...]" will usually represent an array-like index. With Lisp you don't have such visual cues; you have to read the function name and perform a mental translation (lookup) of that function name to "find" a purpose in order to know what the "parenthesized unit" is. Thus, it's more mental steps to compute the general meaning of the code. One is mentally searching (mapping) on name, not visual appearance. Lisp fans seem to perform this lookup faster than average. Whether it's because they've been doing it for so long or they have an inborn knack is unknown. It would make a fascinating area of research. I tried to get the hang of name-based fast recognition, but was progressing too slow for my comfort.
- lispm 7y agoLisp code usually has a complex tree like indentation & layout. Indentation is provided as a standard service by editors and by Lisp itself. See the function PPRINT as the interface to the pretty printer, which does layout and indentation of source code. We look for visual tree patterns. For example the LET special form: LET BINDINGS BODY or more detailed LET VAR1 VALUE1 VAR2 VALUE2 ... BODYFORM1 BODYFORM2 ... The list of binding pairs is another common pattern. There is a small number of tree patterns which are used in the core operators of Lisp. Once you've learned them, reading Lisp is much easier than most people think. CL-USER 13 > (pprint '(let ((one-number 1) (two-numbers 2) (three-numbers 3) (four-numbers 4) (five-numbers 5) (six-numbers 6)) (+ one-number two-numbers three-numbers four-numbers five-numbers six-numbers))) (LET ((ONE-NUMBER 1) (TWO-NUMBERS 2) (THREE-NUMBERS 3) (FOUR-NUMBERS 4) (FIVE-NUMBERS 5) (SIX-NUMBERS 6)) (+ ONE-NUMBER TWO-NUMBERS THREE-NUMBERS FOUR-NUMBERS FIVE-NUMBERS SIX-NUMBERS))
- tabtab 7y agoAll indentation does is tell you that there is a hierarchy of some sort. The fact something is one level deeper than another still doesn't tell me generally what it does, because that depends on what the parent(s) does. And it's not a difference maker because "regular" language can also use indents. Further, the coder decides the indentation, and I'm not convinced it's consistent enough. In my example, a curly brace is a curly brace regardless of a coder's preference. It's enforced by the rules the language, not the coder. Another thing I'd like to point out is that languages like JavaScript provide two levels of common abstraction. Using curly braces, parenthesis, and square brackets as an example, you spot them and immediately know the forest-level category something is: code block, function call, or array/structure index. With Lisp, all you are guaranteed have is the function name (first parameter), which you have to do a mental name-to-purpose lookup, which could involve thousands of names. Splitting the lookup into levels improves the mental lookup performance, at least in my head. It also helps one quickly know to ignore something. For example, if I'm looking for a code block, I know I can probably ignore array indexes, and vice versa. It's forest-level exclusion, which is hard to do with single-level lookups because the list is too long: it has to contain the general category of each name. It's extra mental accounting. Hard-wiring in big-picture categories into the syntax allows quickly making forest-level reading decisions, and which individual coders generally can't change. When it comes to team-level read-ability, consistency usually trumps abstraction and many other things. Maybe Lisp can do something similar with "let", bindings, and body, but then it starts to resemble "regular" languages, along with their drawbacks, which is typically less abstraction ability. Consistency "spanks the cowboys", both the good cowboys and the bad cowboys. But at least you know what you have, and can estimate and plan accordingly.
- hinkley 7y agoIn particular I’m thinking of architectural astronauts who get excited about a “system” they want to build (or god forbid, already have built) where “everything is a foo”. The hallmarks of these systems include: lots of very self-similar code - often recursive, very low inclusion of domain nouns and verbs, and instead substituting a new (impoverished) domain that is full of vague nouns and verbs (like “node”, “execute” or “handle”). In the worst cases, different parts of the code use a separate definition of the vague nouns. Such people would (and at least one case that I’ve seen, have) rush to call their system homoiconic. I think because they’re more interested in looking clever than being helpful. Not only is such code hard to follow, but as one smart person once put it, any time your code uses different concepts than those from the problem domain, there’s a place where impedance mismatches live. Those look like bugs to your users, and are often the hardest to fix. As the other responder guessed, this is a part about lisps that I’m not overfond of. It’s easier for such frippery to expand to the entire system.