MPS screen-casts

This page lists and categorizes the MPS-related screen-casts published at the MPS channel of JetBrains TV.

Who and how uses MPS. Watch the MPS customers presenting their use of MPS.

• Why JetBrains MPS - an overview video about MPS, who should care and why.

• The Voice Menu IDE - a more thorough example of what MPS can do. A voice menu definition language is used as a sample domain to illustrate the potential of MPS.

• Why the mbeddr.com project uses MPS - mbeddr.com explores the benefits of language extension and formal methods for embedded software development. We have implemented the C programming language in MPS, which allows us to extend it in a meaningful way, for example, with state machines, physical units or with support for product line variability. In this screencast we briefly explain why we chose MPS for this project.

• Modelwerkstatt application of MPS (part 1 and part 2) - modellwerkstatt.org in Innsbruck, Austria use MPS to develop powerful DSLs for building enterprise applications. The whole development process is realized with MPS. Watch this two-part screen-cast to get a taste of what MPS brings to the table in this particular domain.

Two videos giving you the initial insight into how MPS works.

• The first run - essential information for total beginners into how MPS is organised, how it works and how users are supposed to interact with it.

• The Robot Kaja sample - your first time with MPS - a detailed description of MPS from the user perspective.

• The MPS projectional editor - an explanation of the principles of the MPS projectional editor, the differences from textual editors and the benefits of this approach.

• The Robot Kaja language implementation - your second time with MPS - a detailed description of MPS from the language designer perspective.

Watch this series of short introductory videos to get a bird's-eye-view of how languages get defined in MPS. After watching the whole series you'll know the steps necessary to define a language and you'll better understand the whole picture.

Videos covering the core principles of building DSLs with MPS.

• MPS basics - creating your first language - This introductory screen-cast should help MPS new-bies to get over the common difficulties that they are likely to face when creating their first DSLs. We'll go through the three fundamental steps of creating a DSL - defining the language structure, the editor and the generator. Watch this short demo if you are new to MPS and want to dip your toe in the basics of the DSL definition process.

• MPS basics - enhancing the language of constants - This second in the series of introductory screen-casts aiming at MPS freshmen builds on the simple language for constants created in the previous episode, polishes several of its glitches and enhances the DSL with expressions and variable types. We'll also touch on importing languages and defining simple constraints.

• MPS basics - types and scopes of references - In the third episode of the MPS introductory series of screen-casts we're going to enhance our experimental constant language with references, simple type system rules and scoping constraints.

• MPS basics - intentions and AST manipulation - The fourth episode of the MPS basics series demonstrates Intentions and the ways you can manipulate the AST of your Domain Specific Languages. If you want to provide a smooth and pleasurable user experience to your DSLs, this screen-cast is for you.

• MPS basics - generating text with TextGen - In the fifth episode of the MPS beginners' series you'll familiarize yourself with the TextGen aspect. We'll take our MPS-based DSL and generate Ruby code from it.

• MPS basics - checking rules and quick fixes - Static code analysis helps developers discover and eliminate bugs and problems in the code quickly. By highlighting suspicious pieces of code and offering automatic refactoring to fix the code, modern IDEs safe development time and reduce the number of software defects. MPS expands this capabilities to the field of domain specific language.

MPS doesn't live in vacuum. It can be used standalone as well as integrated into other development environments. Check out these screen-casts for the details.

• How to package your DSLs for IntelliJ IDEA - Watch this screen-cast to learn how to build and package your languages so that they can be shared with others and used inside both MPS and IntelliJ IDEA. We'll create a build script for a sample language that will compile, build and package the language and create a proper IntelliJ plugin zip file.

• How to enable MPS in IntelliJ IDEA - Watch this screen-cast to learn how to add MPS core capabilities to IntelliJ IDEA and how to import third-party languages. We'll go through the various options that enable the MPS plugin inside IntelliJ IDEA, configure the plugin, create our first demo and run it. We will then import a separate language plugin in order to use the contained language in our code.

These screen-casts dive deeper into the waters of MPS language definition.

• Context Assistant - This video shows the use and definition of context assistant for the sample robot Kaja language.

• Context Actions Tool - This video shows the use and definition of context actions tool.

• Context Assistant for language definition - This video highlights the guidance that Context Assistant provides within the language definition languages - structure and editor.

• Transformation Menu Language - This video explains the new Transform Menu Language, which is used to define side-transformations, substitutions as well as other context-sensitive actions in the editor.

• Smoothing the Editor Experience
• Optional Visibility in the Editor
• Using Editor Components

• Using the MPS Console to investigate and update the user models.

• Checkpoints, cross-model generation and generation plans - This video shows how to define generation plans in order to enable cross-model generation. It also highlights th persisted checkpoint models, which help debug the persisted mapping labels.

The Shapes tutorial video demonstrates the Shapes language in the Shapes tutorial.

These videos accompany the introductory Calculator Language tutorial.

• The introductory Calculator Language Tutorial - This screencast provides an alternative way to learn MPS. Following the steps described in the on-line introductory MPS Tutorial the screencast will guide you through the process of building a Calculator definition language and show you how to use the basic MPS concepts, such as the structure, the editor and the generator. If you find the on-line tutorial a bit dry and difficult to follow, this screencast may help you get over it.

• The introductory Calculator Language Tutorial - constraints and type-system - This is a second part of the Calculator Language Tutorial covering constraints and type-system. This screencast provides an alternative way to learn MPS. Following the steps described in the on-line introductory MPS Tutorial the screencast will guide you through the process of creating scoping constraints and simple type-system rules for the Calculator Language we built in the first part.

1. Introduction to JetBrains MPS, part 1: Projects - This episode covers the MPS project setup and organisation of modules and models including their dependencies.

2. Introduction to JetBrains MPS, part 2: Structure - This episode provides a brief theoretical background into models, meta-models and abstract syntax trees and then applies the knowledge to the MPS structure aspect.

3. Introduction to JetBrains MPS, part 3: Constraints - This episode details the constraints aspect of language definition in MPS, mainly how to restrict properties, links and how to define scopes.

4. Introduction to JetBrains MPS, part 4: Behavior - This episodes adds a few useful tips on adding functionality to concepts and nodes.

5. Introduction to JetBrains MPS, part 5: Editor - Make'em see your code - defining editors that project the AST on the screen.

6. Introduction to JetBrains MPS, part 6: Actions - Polish the editors - smoothing the editing experience by defining transformations and substitutions.

7. Introduction to JetBrains MPS, part 7: Intentions - Assist the developer with context-sensitive hints and refactorings.

8. Introduction to JetBrains MPS, part 8: Generator - Converting models - defining model-to-model transformations.

9. Introduction to JetBrains MPS, part 9: Text-Gen - Here's what I've written - converting models to text.

10. Introduction to JetBrains MPS, part 10: Dataflow - Go with the flow - defining dataflow definitions so that MPS could automatically detect issues in code structure.

11. Introduction to JetBrains MPS, part 11: Type-system - They are just my type - defining types and type-system rules to validate expressions early-on.

You may also watch these as a single YouTube playlist.