I am a huge fan of the idea of meta-programming, and I've thought a lot about how to implement such a system myself, but have never gotten around to doing it (too busy with other work!) However, I had hoped that eventually someone else would try to build such a thing, and I'm glad you guys have taken a stab at this.
One general comment: perhaps I am in the minority here, but I find the UI conventions used in MPS highly non-intuitive. Perhaps these are Java standard UI conventions --- but I really think they ought to be rethought. For example, double-clicking on a selection in the Ctrl-Space code completion popup should select the item; instead, you have to click then hit enter. Or another example, when you're able to edit in a text edit field, there should be some sort of blinking bar cursor the way every other text edit field in the universe operates. It seems to me that following basic UI conventions common in, say, web browsers or pretty much every windowing system from Windows to KDE to Gnome to whatever would go a long way to improving the user experience of people unfamiliar with the tool.
That's a fairly minor quibble however. A much bigger complaint is that it takes far too many steps to do common tasks. Conceptually, I believe (particularly with meta-programming systems) in "simple things should be simple, complex things should be possible." The Hello World example takes a huge number of separate steps (clicking on things, creating things, etc., etc.) which should be boiled down to the absolute minimum number of steps. Which brings up the question: I would hope (but I haven't studied MPS carefully enough to know) that it might be possible to build an MPS language that is meta to the whole MPS process. I.e., would it be possible to solve the problem of a huge number of steps by writing an MPS language that would "macro-ize" some of these steps?
For example, the process of creating a class template that just maps a single text constant property in a concept to a System.out.println(property); code generation should be an absolutely straightforward task. It shouldn't take umpteen kazillion separate UI operations. I should be able to do something, conceptually, like:
1) define concept HelloWorld with single string constant property helloText
2) define template which says: concept HelloWorld maps to a class definition in baseLanguage, HelloWorld[possible macro to disambiguate]
3) define template method which says: static method main() with System.out.println(concept HelloWorld.helloText);
It seems to me the above 4 steps are conceptually all you should need and the UI ought to be able to boil these steps down somehow and do all the gobbledegook in the background to actually hook all this stuff up. Is it possible to do this already in MPS? I.e., can MPS operate in its own abstractions? I would imagine and hope the answer is yes, and I'm curious to find out the answer.
I also think that there should be some consideration for small mini-parsers to make it easier and more fluid to enter code. Structured editing is fine for a lot of things, but inputting System.out.println($HelloWorld) took far longer with all the mouse clicks and menu selections than it would have taken me to just type the above. Meta-programming should be faster than regular programming! There really should be more support for more free-form text editing and for many situations generating small parsers ought to be doable. Obviously there are all the problems of disambiguation with parsers, but it seems to me in those cases you just ask the programmer what they want and in 99.5% of the cases the parser ought to be able to figure out what the programmer means from context, at least for languages that are expressible in text format. Naturally this wouldn't work for all languages, but there ought to be a significant number of minor variations on baseLanguage that ought to allow this sort of thing.
Code completion and all that is great, but it ought not to be something that the programmer MUST use, it should be something that programmer CAN use.
Note: I've written IDEs myself, for my own use, and I found that at the level of things like instance variables, methods, classes, etc., having structured property editors is invariably faster than typing text for a wide variety of reasons. But for a few lines of imperative code --- it's often easier to just type text.
I suppose the above post is really three separate comments, but I welcome responses from the MPS team on any of these ideas.