
JetBrains' MPS Projectional Editor [video] - pron
https://www.youtube.com/watch?v=iN2PflvXUqQ
======
Too
Looks similar to how mathematica works, there you also type \sum <tab> and it
will transform into the mathematical sum symbol and guide you to what should
be filled in next with empty boxes. Really cool that they managed do
generalize this and make it available for developers.

I'm mostly worried about copy-paste becoming troublesome, one of the biggest
advantages of text editing is that it's so raw and if you know your tools you
can transform a lot of it quickly instead of being constrained to repetetive
clicking through clunky wizards and menus with your mouse.

~~~
tyilo
Don't you mean <esc> sumt <esc> ?

------
arkadiyt
If you enjoy these types of compiler videos then I would highly recommend the
following rants against Scala by Paul Phillips (from TypeSafe and one of the
core language contributors). He also talks about wanting to edit abstract
syntax trees directly:
[https://www.youtube.com/watch?v=TS1lpKBMkgg](https://www.youtube.com/watch?v=TS1lpKBMkgg)
[https://www.youtube.com/watch?v=uiJycy6dFSQ](https://www.youtube.com/watch?v=uiJycy6dFSQ)

------
NinoScript
I think this could be the future. Some tools (like Emacs' Paredit) are trying
to do things like this with text but I think projectional editing is a better
solution.

The problem is that it will take some kind of miracle or great revolution for
it to ever have a place in our workflows.

------
muescha
One caveat with this projectional editor:

Not possible to copy and paste of code inside editor

Not possible to copy code snippets (for example from a website) and pasting
into the editor.

Thats very weired to write the code - you can not write natural a text

(Tested with the workflow editor from youtrack - it was a bad experience)

------
escherize
Really nice tooling. I like how the editor guides you 'fill in the next
blank'.

Since you write the AST directly, this seems to be a lisp without parentheses.

~~~
jbnicolai
Rather, 'under the hood' it _is_ a lisp (that is, an AST). The powerful
feature here is that you visualize (project) the AST into a more concise
representation

~~~
pron
All programming languages are represented as ASTs under the hood. There's no
need to call an AST a Lisp.

------
lobo42
From someone who compared MPS with Xtext : "2 days of work in MPS were
recreated in 30 min using XText"

[http://arnon.me/wp-content/uploads/2015/06/DSL-
summary.pdf](http://arnon.me/wp-content/uploads/2015/06/DSL-summary.pdf)

------
k__
If a JavaScript dev likes the idea of AST refactoring, I recommend a look into
grasp[]. It's like grep but works with the AST representation of a file
instead of the Text.

[] [http://www.graspjs.com](http://www.graspjs.com)

------
ingenter
Somehow, I shudder when thinking about meta-programming and DSLs in Java.

~~~
mike_hearn
The point of the idea is, if you combined meta-programming and DSLs with Java,
you don't have Java anymore. MPS calls their Java dialect "baseLanguage" and
it's actually Java + a lot of small DSLs with custom renderings and editors.

MPS is one of the most mind blowing developer projects I ever encountered. But
I first played with it years ago and have tried most versions since, and
unfortunately it never made it past the "cool, neat, but I don't have a use
for it" stage. Somehow I always end up back with regular IntelliJ and Java or
Kotlin.

One reason: MPS is one of those concepts that's just such a huge leap over
what we do today, I worry about losing other possible contributors if I use
it. Also, for example, the projects are stored as giant XML files on disk, so
github diff viewers and other text based tools wouldn't work. Perhaps I should
just take the leap for a small personal project.

~~~
pjmlp
If you look at online demos how the Xerox PARC and Symbiotic systems were
being used, it is not far off from MPS and similar.

Yet here we are still trying to make it mainstream.

