One of these is not like the others.

Let’s say you have all of these plugins installed in your MPS and are developing your language. You use grammar cells to save on the effort of writing editors, Durchblick to have a better view of generators, Fernsprecher to view MPS logs, and Build Script Notifier to remember to update build script dependencies.

Now the time comes to distribute your language to the users. Which plugins do you need to include in the final package so that the consumers will be able to use the language?

The answer is: only grammar cells.

All the other plugins improve your “working conditions” by enhancing the development environment. Whether you used those plugins or not, generating and compiling your language produces the same result. Your users do not need these plugins to use your language.

With grammar cells it is a different story. This plugin is a reusable library. The language you write is tied to it and will not work without the library available.

It is not important whether the language was developed with version X or Y of Durchblick or Fernsprecher. On the other hand, knowing and using a specific version of grammar cells can be very important. Version Y may contain a fix for a particular bug or a feature you want to use that is not part of version X.

Automatically updating the IDE-enhancement plugins is usually desirable. Automatically updating the libraries? Usually not.

In the world of non-meta IDEs this distinction is quite clear: you get a JSON file plugin from JetBrains Marketplace but you get Gson or Jackson JSON parser library from a Maven repository.

In the world of MPS this distinction is unfortunately less clear, and it is made worse by the fact that MPS-extensions are available on JetBrains Marketplace.

I recommend you avoid using library plugins from the JetBrains Marketplace, except for initial small experiments or demos (a single person trying out things on a single machine). As soon as you need to distribute your language to others, even if it is just a proof of concept, consider setting up a Maven or Gradle build to download the specific versions of libraries from a package repository. This investment will save you some headaches.

• Understanding the difference between two similar terms. If a domain expert uses parameter once and configuration variable next, are they the same thing or are they different?
• Using the proper terms in each situation. If a parameter and a configuration variable are indeed the same thing, use only one of the terms consistently. If they are different, use the correct term each time.
• Realizing when the other side is not using the terms correctly and dealing with it.

Why is it important? This ties in with one of the reasons why we develop languages in the first place: help our users speed up their work by making fewer mistakes and spending less time correcting them. Misunderstandings about terms are a major source of errors, both for our language users and for ourselves as language developers. At the same time, misunderstandings are fairly easy to correct once you tune yourself to looking for them.

How can one develop the skill of making distinctions? I believe it is mostly about strengthening your intuition. You might get a feeling that something is “a bit off” in whatever you are hearing or reading. This feeling may be weak, irrational and easy to dismiss. Instead, take it seriously and reflect on it. Try rephrasing what you read or hear in your own words, see what terms you are inclined to use naturally, and if they are different from the original terms, what is the difference in meaning?

Some modeling tools work like this, too. They manage a relational database of “things” and relationships between them (often called a repository), and when you remove a thing, all relationships that refer to it are removed as well.

However, MPS is closer in spirit to an IDE (or perhaps to a NoSQL database). Your Java IDE does not remove a class after you stopped using it in your code, nor does it remove all references to a class if you delete it.

A Java IDE provides refactorings and can search for usages of a given class and highlight unused program elements. MPS can do both, too. But referential integrity is not something that MPS can provide out of the box.