Child pages
  • Master Theses Topics
Skip to end of metadata
Go to start of metadata

General topics

JetBrains MPS is an open source language workbench that allows developers and language designers to easily build their own programming languages or extend existing ones. For more details, please check out the MPS website.

1. Grammar to JetBrains MPS convertor

JetBrains MPS is an open-source language workbench focusing on Domain-specific Languages (DSL). Unlike many competing language workbenches and in contrast to the industry prevalent approach, MPS uses a projectional (structured) editor for editing code. The developer directly manipulates the program in its tree (AST) form. The code is always represented as AST, including the persistence format, which avoids the need for parsing text.

This approach was chosen in order to give language authors:

  • greater flexibility of the language syntaxes – tabular, graphical, textual or form-like notations are all possible
  • ability to switch between notations on-the-fly and thus view the same code in different ways depending on the task at hands
  • modularity of languages, which enables languages to be easily combined – extended, embeded, reused or referrenced from one another

While the majority of programming languages in the industry are currently defined using grammars, languages in MPS are codified using principles of object-oriented programming. Since MPS does not rely on parsing, but instead uses a projectional (structured) editor and layered code generation, existing GPLs that should be made editable in MPS need to be re-implemented using the MPS language definition facilities. The up-front cost of manually re-defining existing languages in order to use them in MPS is a major obstacle that turns away many projects that could potentially benefit from the MPS platform.

This thesis should elaborate on the possibility to automate the process of creating MPS language definition from existing grammar definitions. This would simplify and speed up the process of migrating existing languages (both GPLs and DSLs) to the MPS platform and thus encourage MPS adoption both between researchers and in the industry.
The outputs of the thesis will be distributed under the open-source Apache 2 license and available for free download. All outputs including documentation will be in English. JetBrains will provide a technical consultant to assist with MPS adoption.

Goals:

  • Design and implementation the grammar to MPS convertor, possibly building on top of existing prototypes
  • The three essential aspects of language definition in MPS should be covered by the tool - abstract syntax (structure), concrete syntax (editor) and text generation (text-gen)
  • Demonstrate the capabilities of the translator by translating a single GPL and a few DSLs

Expected output (one or more of):

  • A functional implementation of the grammar to MPS convertor
  • Examples of automatically converted languages
  • Analysis of the principal issues, both solved and unsolved, with respect to automated conversion of grammar definitions

Resources:

2. Haskell/Frege IDE with JetBrains MPS

Haskell is a purely functional programming language with strong typing and advanced DSL capabilities. Frege is an open-source project that aims to bring Haskell to the Java ecosystem. This practical thesis should focus on building typical IDE infrastructure to assist developers when editing, testing and debugging Haskell/Frege code - code completion, error checking, static code analysis, re-factorings, etc. The IDE will be implemented with JetBrains MPS - an open-source language workbench built around a projectional (structured) editor. JetBrains will provide a technical consultant to assist with both MPS and Haskell adoption.

Goals:

  • Haskell syntax described using the MPS structure language
  • Set of intuitive editors for editing Haskell syntax
  • Type-system rules that would identify type errors in the editor
  • Code generators for Haskell/Frege code

Expected output (one or more of):

  • A functional IDE implementation distributable under an open-source license
  • Analysis of the possible synergies between a projectional editor and a purely functional programming language
  • Identify whether and why projectional editing offers more convenience for editing purely functional languages compared to plain-text editors

Resources:

3. JavaScript language support

The idea of this work is to enhance the existing open-source implementation of the JavaScript language for MPS, called Ecmascript4mps. The structure and textgen aspects of the language are already in place, but the editing experience is sub-optimal. This work will focus on the editor, actions and data flow aspects of the language to ensure comfortable use of the language inside MPS. This is a very practical hands-on topic.

Goals:

  • The editor, actions and data flow aspects
  • A basic set of checking rules to help users spot frequent issues in their JavaScript code

Expected output (one or more of):

  • A functional JavaScript language implementation distributable under an open-source license, building on top of the existing implementation

Resources:

4. GPU programming in JetBrains MPS

Modern graphical cards in personal computers contain highly parallel Graphical Processing Units (GPU). These chips are optimized for massively parallel processing of numeric values. Several standards, such as OpenCL or CUDA, have been created to give cross-platform programmatic access to these processors from within Java code. The actual code that runs on the GPU, however, has to be programmed in plain C and compiled separately from the application's Java code.
JetBrains MPS is an open-source language workbench focusing on Domain-specific Languages (DSL). Code written in DSLs needs to be transformed into one or more General-purpose languages (GPL) before triggering the compiler of the target platform and generating binary code.
This thesis should focus on seamless integration of GPU programming into the Java programmers workflow. Ideally, Java programmers should write the code, which eventually runs on a GPU, directly in Java together with the rest of the application. The desire to have a piece of Java code run on a GPU should be expressed by means orthogonal to the actual code - e.g. by an annotation.
The outputs of the thesis will be packaged as an MPS language plugin, distributed under the open-source Apache 2 license and available for free download. All outputs including documentation will be in English. JetBrains will provide a technical consultant to assist with MPS adoption.

Goals:

  • Design and implementation of an MPS language extension that allows Java code to be seamlessly run on a GPU
  • Allow the programmer to indicate at compile-time the intention whether to generate GPU-specific code or whether to generate plain Java code instead
  • Analyze and compare the code-generation approach to the existing alternative approaches

Expected output (one or more of):

  • A functional MPS language extension packaged an an IntelliJ IDEA plugin distributable under an open-source license
  • An MPS language plugin for IntelliJ IDEA that would enable GPU programming in IntelliJ IDEA
  • Analysis of the pros and cons of code generation for this problem domain

Resources:

5. DSLs for education

Explore whether Domain Specific Languages (DSLs) and language workbenches in particular can contribute to teaching programming.

When teaching people to write their first programs and understand algorithms, General Purpose Languages (GPLs), such as C or Java, are too complicated and difficult to use to attract and keep children's attention. DSLs look like a promising way to go (See, for example http://www.infoq.com/presentations/Easy-as-Pie-Teaching-Code-Literacy or http://tv.jetbrains.net/videocontent/your-first-date-with-jetbrains-mps).
This assignment should ideally result in a usable system (DSL and a run-time) that would offer children safe and intuitive ways to learn programming.

Goals:

  • Propose efficient ways to teach programming at young age with focus on languages and problem domains
  • Identify the key characteristics of tools and programming languages that have impact on the process of learning programming

Expected output (one or more of):

  • A study charting the territory, summarizing the current state of the art of the domain, listing the already available tools as well as undergoing research and proposing ideas for further exploration
  • A runnable development environment that would enable children to write their own programs together with a list of further potential improvements to the tool
  • Analysed results of real-life experiments teaching children programming with one or more existing tools

Resources:

6. Literate Programming

Literate programming is an approach to programming introduced by Donald Knuth, in which a program is given as an explanation of the program logic in a natural language, such as English, interspersed with snippets of macros and traditional source code, from which a compilable source code can be generated. The most famous example of a literate program is TeX by Donald Knuth, documented in TeX: The program, volume B of Knuth's Computers and Typesetting.

JetBrains MPS is an open-source language workbench focusing on domain-specific languages employing projectional (structured) editing. This allows for having multiple representations of the same underlying model ("source code") depending on the users' needs.

This thesis should focus on implementing a set of MPS languages and editors for literate programming. The languages should allow writing a document containing code fragments that could then be weaved together to produce an executable program, and the original document itself could be converted to a printable format. The literate programming DSL should make as few assumptions about the implementation language as possible so that different implementation languages can be supported (Java, C, JavaScript, custom DSLs, etc.)

The outputs of the thesis will be packaged as an MPS language plugin, distributed under the open-source Apache 2 license and available for free download. All outputs including documentation will be in English. JetBrains will provide a technical consultant to assist with MPS adoption.

Goals:

  • Explore whether literate programming can be implemented in MPS and what is missing.
  • Determine whether literate programming provides benefits for DSL users.

Expected output:

  • MPS-based DSLs for literate programming.
  • Analysis of challenges encountered while implementing the DSLs.

Resources:

7. Querying NoSQL databases

With the advent modern NoSQL databases a need for targeted query languages, such as Cypher (http://docs.neo4j.org/chunked/1.4/cypher-query-lang.html), has become evident. Explore the field and investigate whether Language Workbenches can make a contribution in this domain. In particular, the domain of graph databases, such as Neo4j, could be interesting.

Goals (one or more of the following):

  • Implement a practical MPS-based query DSL for a chosen NoSQL database like Redis, Riak, Neo4J and other
  • Implement the existing Cypher language with help of MPS and analyze the impact of projectional Language Workbenches in the domain of graph-databases compared to the traditional approaches
  • Analyse the options for integration of such query DSLs into the usual development life-cycle

Expected output:

  • An MPS-based query DSL for one of the NoSQL databases
  • Analysis of how the projectional DSLs fit into the development process, what challenges there are and what benefits they bring in comparison to the other approaches

Resources:

------------------------------------------------------------------------------------------------------------------------------------

Backlog - inspirational, taken and obsolete topics

Alternative computational models

Create languages and simulators that would allow definition of alternative computational models, such as Turing machines or stack machines, and illustrate their processing with graphical animations.

 

Go language implementation in JetBrains MPS

 

Go is an imperative programming language from Google with strong focus towards performance and concurrency. Being primarily a low-level language go lacks the flexibility to easily build expressive internal DSLs.
JetBrains MPS is an open-source language workbench focusing on Domain-specific Languages (DSL). Code written in DSLs needs to be transformed into one or more General-purpose languages (GPL) before triggering the compiler of the target platform and generating binary code. 
Since MPS does not rely on parsing, but instead uses a projectional (structured) editor and layered code generation, existing GPLs that should be made editable and generatable in MPS need to be re-implemented using the MPS language definition facilities. Only then can these GPLs be used as targets for code generation in MPS.
This practical thesis should focus on implementing the Go language in MPS using the MPS language definition capabilities. Bare-bone IDE infrastructure to assist developers when editing Go code should be also created. The outputs of the thesis will be packaged as an MPS language plugin, distributed under the open-source Apache 2 license and available for free download. All outputs including documentation will be in English. JetBrains will provide a technical consultant to assist with MPS adoption.

 

Goals:

 

  • Go syntax described using the MPS structure language
  • Set of intuitive editors for editing Go syntax
  • Type-system rules that would identify basic type errors in the editor
  • Code generators for Go code

 

Expected output (one or more of):

 

  • A functional Go language implementation distributable under an open-source license

 

Resources:

 

 

Transparent code tracing

Design a convenient way for developers to enable transparent tracing for Java code using the JetBrains MPS language workbench. The created solution should be based on a Domain Specific Language (DSL) that will enable developers to specify, which classes, methods, fields or other Java syntax elements need to be traced, and then the target Java code will be automatically enhanced to log the requested traces. Typical events to trace include method enter/exit events, class instantiation as well as field access (separately read and write access). 

Goals:

  • The developers, meaning users of the created solution, should be able to turn tracing on and off for different parts of the codebase using a DSL
  • It should be possible to specify classes, methods and fields to trace individually or as groups
  • The tracing code will be automatically generated only when enabled and solely for the traced parts
  • The language can be developed further to allow definition of the log format or whether and how to log, for example, parameters / return value of a method or changes in field values

Expected output:

  • A complete MPS-based solution containing a newly designed trace definition language (DSL) and a Java-enhancing generator that inserts tracing code into the original Java code

Resources:

Rust language implementation in MPS

 

Rust is a general-purpose, multi-paradigm, compiled programming language developed by Mozilla Research. It is designed to be a "safe, concurrent, practical language", supporting pure-functional, concurrent-actor, imperative-procedural, and object-oriented styles. JetBrains MPS is an open-source language workbench focusing on Domain-specific Languages (DSL). Code written in DSLs needs to be transformed into one or more General-purpose languages (GPL) before triggering the compiler of the target platform and generating binary code. Since MPS does not rely on parsing, but instead uses a projectional (structured) editor and layered code generation, existing GPLs that should be made editable and generatable in MPS need to be re-implemented using the MPS language definition facilities. Only then can these GPLs be used as targets for code generation in MPS.

This practical thesis should focus on implementing the Rust language in MPS using the MPS language definition capabilities. Bare-bone IDE infrastructure to assist developers when editing Rust code should be also created. Rust type checks (including borrow checking) should be implemented. The outputs of the thesis will be packaged as an MPS language plugin, distributed under the open-source Apache 2 license and available for free download. All outputs including documentation will be in English. JetBrains will provide a technical consultant to assist with MPS adoption.

Goals:

  • Rust syntax described using the MPS structure language
  • Set of intuitive editors for editing Rust syntax
  • Type-system rules that would identify type errors in the editor, including violations of borrowing semantics.
  • Code generators for Rust code

Expected output (one or more of):

  • A functional Rust language implementation distributable under an open-source license

Resources:

 

Model-Based and Property-Based Testing

 

Model-based testing is a software testing technique, in which the test cases are derived from a model of the system under test. The model-based approach has several advantages: the necessity of having a formal model of the system leads to higher clarity in requirements, thus reducing errors in the implementation. Another advantage is the possibility to tune the test generation process to improve characteristics such as test coverage or run time.

Property-based testing is a technique where the behavior of the system under test is specified as a set of properties rather than individual examples. The test execution software then generates example values and checks whether the properties hold, in an attempt to falsify them. A canonical example of property-based testing is the QuickCheck library written in Haskell.

JetBrains MPS is an open-source language workbench focusing on domain-specific languages (DSLs).

The goal of this thesis is to design a set of languages for model-based and/or property-based testing Java (BaseLanguage) applications. As a proof of concept a simple but non-trivial test suite for MPS could be produced.

The outputs of the thesis will be packaged as an MPS language plugin, distributed under the open-source Apache 2 license and available for free download. All outputs including documentation will be in English. JetBrains will provide a technical consultant to assist with MPS adoption.

Goals:

  • Explore different ways a system may be modeled for the purpose of testing.
  • Explore different ways in which test cases may be generated from a model of a system.
  • Design and implement a DSL (or a set of DSLs) for model-based testing.

Expected output:

  • MPS DSLs for model-based and/or property-based testing
  • A suite of tests for a non-trivial application written in the above DSLs.

 

Resources:

 

Robot Karel IDE (taken)

Robot Karel has been used for teaching programming to children for several decades. MPS comes with a sample Karel language implementation bundled (see http://tv.jetbrains.net/videocontent/your-first-date-with-jetbrains-mps and http://tv.jetbrains.net/videocontent/your-second-date-with-jetbrains-mps). As part of this assignment the prototype implementation should be extended with additional functionality to accommodate for real needs of children education. The resulting language should be turned into a standalone application, which allows students to interactively develop their programs as well as run, debug and test them.

Goals:

  • Fully implemented Karel language, potentially modularized into several extensions bringing additional capabilities to the language
  • An easy-to-use MPS-based IDE for the Karel language, which allows for intuitive user interaction

Expected output:

  • A runnable development environment for the Karel language that would enable children to write their own programs
  • Analysis and implementation of useful extensions to the Karel language that would have positive impact on the education process and expand the learning experience into other programming domains, such as object-oriented or functional paradigm

Resources:

CSP-style concurrency

Communicating Sequential Processes (http://en.wikipedia.org/wiki/Communicating_sequential_processes) is a solid high-level concurrency model with implementations in many programming languages(e.g. http://golang.org/orhttp://www.cs.kent.ac.uk/projects/ofa/jcsp/). The thesis should focus on building an intuitive extension to Java that would embed the CSP model in MPS, perhaps leveraging the Java JCSP library. This assignment is a practical exercise in Domain Specific Language (DSL) design and implementation over an existing library.

Goals:

  • Explore whether language extensions, as implemented in MPS, provide a suitable vehicle to deliver concurrency models into general-purpose programming
  • Discover the challenges along the way
  • Find out limitations of such an after-thought approach compared to alternatives that support concurrency on the language level (e.g. Google Go)
  • Analyze the benefits and the level of integration such language extensions can offer

Expected output:

  • An extension to Java (aka MPS BaseLanguage) that would bring CSP into the language

Resources:

 

Building a DSL debugger with MPS for real-time Java

This is a task related to Real Time (RT) Java support in MPS. The idea is to create a debugger (which is most probably missing now) for the RT Java BaseLanguage extension.

Goals are:

  • develop all necessary debugger-specific aspects for RT Java language basing on built-in Java debugger capabilities of MPS
  • develop integration of MPS debugger with RT java VM
  • provide view for RT JVM-specific properties for each object in debugger snapshot in MPS

Resources:

  • No labels