JetBrains MPS is an environment for defining new languages and language extensions. It allows users to freely define DSLs which are fully integrated. Language designers define a DSL using its schema, editors, and generators. The document discusses MPS features like abstract and concrete syntax, generation, type systems, dataflow analysis, debugging, testing, refactoring, and extensibility. The goal is to initiate discussion on developing advanced IDE functionality for DSLs.

1. JetBrains MPS
Developing advanced IDE functionality
for your DSLs
Alexander Shatalin
Václav Pech
JetBrains, Inc.
www.jetbrains.com
1

2. Goal
We’ve gone a long way charting the territory
and want to share our part of the map
=> to initiate discussion and ideas
www.jetbrains.com
2

3. Language Workbench
■ Users can freely define new languages which are
fully integrated with each other.
■ The primary source of information is a persistent
abstract representation.
■ Language designers define a DSL in three main
parts: schema, editor(s), and generator(s).
■ Language users manipulate a DSL through a
projectional editor.
■ A language workbench can persist incomplete or
contradictory information in its abstract
representation.
Martin Fowler
www.jetbrains.com
3

4. JetBrains MPS
MPS stands for Meta Programming System
JetBrains MPS is an environment for:
- defining new languages and language extensions
- writing and running/debugging programs in these
languages
www.jetbrains.com
4

5. Agenda
• Abstract and concrete syntax
• Generation
• Type-system
• Dataflow
• Version Control Support
• Debugging
• Testing
• Refactoring
• Extensibility & Modularization
www.jetbrains.com
5

6. Categorization
Parser-based x Projectional
www.jetbrains.com
6

7. Abstract syntax
www.jetbrains.com
7

8. Node definition
www.jetbrains.com
8

9. Structural constraints
Type of a property
Child cardinality
www.jetbrains.com
9

10. Model Validation
www.jetbrains.com
10

11. Behavior
www.jetbrains.com
11

12. Annotations/Attributes
Seamlessly add children to existing concepts
in a generic way
www.jetbrains.com
12

13. Annotations/Attributes
www.jetbrains.com
13

14. Concrete syntax
Editor
www.jetbrains.com
14

15. Actions and Intentions
Improve the user experience in the editor
www.jetbrains.com
15

16. Generator
Model to model
transformation
Model to text
generation
www.jetbrains.com
16

17. Editing target language templates
IDE support required
This is model-to-model transformation
www.jetbrains.com
17

18. Text generation
www.jetbrains.com
18

19. Our goal
Use the same language for all generation steps
www.jetbrains.com
19

20. Challenges
Use template language in text generation
Good IDE support in templates
Extensible generators
Fast is good
Incremental generation
In the background - in an outside process
Parallel generator
www.jetbrains.com
20

21. Type-system
Fast and Extensible
Visible in other aspects (e.g. actions)
Type-system is described through a DSL
www.jetbrains.com
21

22. Type-system rules
Type equality, inequality
Replacement, Sub-typing, Comparison and
Checking rules
www.jetbrains.com
22

23. Type-system rules
www.jetbrains.com
23

24. Dataflow
Dead code
Potential NPE
...
www.jetbrains.com
24

25. Unreachable code
www.jetbrains.com
25

26. Potential NPE
www.jetbrains.com
26

27. Dataflow Analyzers
Customized dataflow validation
www.jetbrains.com
27

28. Version Control support
Version control integration should be
implemented for projectional editors
similar to text-based IDE approach
www.jetbrains.com
28

29. Debugger
Useful for development of IDE aspects for DSL
as well as for any other SW development
Application x language debugging
www.jetbrains.com
29

30. Debugging MPS Type System rule
www.jetbrains.com
30

31. MPS Type System trace
www.jetbrains.com
31

32. Challenges
Improve debugger definition to abstract it from
final target language
Provide access to DSL variables in evaluation
www.jetbrains.com
32

33. Testing
There are two aspects of testing a DSL:
IDE functionality
Code generator
JUnit extensions used in MPS
type-system testing, editor testing, ...
www.jetbrains.com
33

34. Testing IDE functionality
www.jetbrains.com
34

35. Testing IDE functionality
www.jetbrains.com
35

36. Testing Code generator
Execute code generator upon test set of input
models/programs & check there are no errors
Compare generated code with same code
generated before
Compile generated code
Run generated code
www.jetbrains.com
36

37. Challenges
Providing support for testing IDE aspects of
DSLs
No support from MPS side for running
generated code now
Convince the developers to write tests
www.jetbrains.com
37

38. Refactoring
A well-known problem
Solutions:
Packaged refactorings (e.g. Eclipse)
Preserved refactorings
Migration scripts
Language versioning
www.jetbrains.com
38

39. Extensibility
DSLs must be extensible
Use set of languages instead of single huge
DSL
Modular DSL design should simplify DSL
adoption
www.jetbrains.com
39

40. How to develop better DSLs?
One way: Lower the barrier to entry
Integrate with common-place IDEs
www.jetbrains.com
40

41. Summary
Spread the DSL idea far and wide ...
www.jetbrains.com
41

42. Q&A
Thank you!
www.jetbrains.com
42