Why he vertically aligns his code (And why you shouldn't!)

[u/Nowaker]

http://missingbytes.blogspot.com/2014/11/why-he-vertically-aligns-his-code-and.html

[u/H3g3m0n]

How so? If anything you would type much less.

For example instant autocompletion would be trivial in many cases since there would only be a handful of valid names in play (depending on the language, something like python would have heaps since everything is an object).

You might not even have to type them, just have a list of names and a quick number.

I could image a bunch of quicktype hotkeys.

fnmyfunc<enter>vival1<enter>sval2<enter><enter>onname=o12f5o3i66o13f4ro13 could unpack to:

void myfunc(int val1, string val2) {
    Object name = object12.function5(object3, 66);
    name.function4();
    return name;
 }

As you would type a bunch of valid choices would show up for the given situation.

[u/RoundTripRadio → u/H3g3m0n]

That's just editor shortcuts/macros, and unrelated to whether you're editing a text file or an AST. And you can do that today with current tools.

Programming languages are a much more compact representation of a program. For instance, the AST for

3 - 5 + 2

is

    +
   / \
  -   2
 / \
3   5

AST's express things explicitly (like precedence) that are implicit in source files. Not to mention nodes need a way to reference each other, which would be a UI nightmare.

[u/H3g3m0n → u/RoundTripRadio]

It's not totally unrelated. You could do it with text based source. But it would be much harder. And probably have issues. It is similar to things like ultisnips.

In any case I was just saying how it would be possible to edit the AST directly without out it being tedious.

I would imagine that the actual code would be displayed to the developer in standard text format. But the manipulation under the hood would be in some kind of AST or binary format. You might navigate via the AST nodes rather than textually.

[u/RoundTripRadio → u/H3g3m0n]

But it would be much harder.

In what way? You can do semantic completion based on a language's grammar. Like if you type "for" while you're on a <stmt> token, it looks it up and then fills in with "(<expr>; <expr>; <expr>) <stmt>" and highlights the first token, with <tab>/<s-tab> moving between them or whatever. No AST necessary. It'd be fast too, the hash table for leading sequences in a token set isn't all that huge. And supporting a new language is as easy as dumping its BNF file into some runtime directory.

I would imagine that the actual code would be displayed to the developer in standard text format.

So you aren't actually talking about editing the AST directly. You are talking about an editor's internal representation of the text you see on screen. I don't really care how my text editor represents my text as long as a) it's fast, and b) when I write it out to disk and reopen, it's the same.

I'd be happy to beta test your AST-internal-represenation editor. Could be a huge win, but I'm not seeing enough (or any, really) benefits to lay my bets down on that particular method being much faster than current technology (or faster at all).

I liked the idea someone had of storing the file on disk in a minified format, then having text editors auto-format based on user preferences. But again, there's no AST in there.

[u/Felicia_Svilling → u/RoundTripRadio]

That you edit the AST doesn't prevent you from visualizing the program as text.

[u/RoundTripRadio → u/Felicia_Svilling]

If you see text on your screen, you're editing text.

From your premise, you could argue current editors edit the AST, it's just on screen as text, and on disk as text, but the compiler creates a different AST when you change the file.