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. Type-system implementation for C# (bachelor or diploma thesis)

An implementation of C# for JetBrains MPS has been created as a student project and is now available as an open-source project. The idea of this work is to implement type-system for the C# language using the facilities of MPS. This work will bring into live highly theoretical principles that the new type-system support in MPS builds on. The project will become part of the open-source C# language plugin. JetBrains will provide a technical consultant to assist with both MPS and Haskell adoption.

Goals:

Expected output (one or more of):

Resources:

2. Kotlin language support (student project)

The idea of this work is to implement the Kotlin language in MPS. This practical thesis should focus on implementing the language syntax as well as building typical IDE infrastructure to assist developers when editing, testing and debugging Kotlin 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:

Expected output (one or more of):

Resources:

3. Grammar to JetBrains MPS convertor (diploma thesis)

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:

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:

Expected output (one or more of):

Resources:

4. Querying NoSQL databases (diploma thesis)

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):

Expected output:

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.

 

GPU programming in JetBrains MPS (diploma thesis/student project)

 

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). Its projectional editor allows rich notations, such as math vectors and matrices to become first class citizens in programming languages. 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:

 

 

Expected output (one or more of):

 

 

Resources:

 

 

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:

 

 

Expected output (one or more of):

 

 

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:

Expected output:

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:

Expected output (one or more of):

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:

Expected output:

 

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:

Expected output:

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:

Expected output:

Resources:

 

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:

Expected output:

Resources:

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:

Expected output (one or more of):

Resources:

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:

Expected output (one or more of):

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:

Resources: