JetBrains Students' Day

Reflection is the ability of a program to manipulate as data something representing the state of the program during its own execution. A simple reflection example is type identification which is very common in modern languages. In simple words, it is checking the type of an object or subclasses relation. Examples of type identification are instanceof and is operators in Java and Kotlin respectively.

In our project, we consider one of the reflection tasks: collecting all the classes, object expressions, and functions that satisfy some search condition. We limit this task only to cases where all entities can be found during the compilation of the project.

This task is very common for various Java and Kotlin applications.

Reflection approaches can be divided into two groups according to the execution time: runtime and compile-time.

Runtime approaches usually scan all classes from ClassPath and use Java Reflection API under the hood. The most popular libraries from this group are Reflections and Classgraph. Their main drawback is performance degradation caused by the ClassPath scan, which can be very important in some cases, including Kotless.

Secondly, they have limited integration into GraalVM. GraalVM is a high-performance JDK distribution designed to accelerate the execution of applications written in Java and other JVM languages, e.g. Kotlin.

Compile-time approaches usually index classes from ClassPath during the project's compilation and use this information at run-time to avoid scanning ClassPath again. However, to detect classes that should be scanned developers should mark classes with special annotations manually. It increases code complexity. Moreover, if the used annotations are changed, it is necessary to find and change all of them in the source code throughout the whole project.

This approach also does not solve a more general task, for example, searching for functions by a custom user condition.

All the described approaches have their pros and cons, we propose a new approach leveraging the Kotlin compilation process. Reflekt is a Kotlin compiler plugin that provides means to search for classes, objects (singleton classes in Kotlin), and functions in Kotlin source code at compile-time. Reflekt consists of three main parts: two DSLs - with core and extended functionality; a Gradle plugin to make it possible to use the plugin in a project; and a Kotlin compiler plugin that implements compile-time resolution of reflection queries.

We have several open tasks:

• support incremental compilation
• add new query types, e.g. finding sealed subclasses (and several similar tasks)
• support finding entities in Java code
• replace KotlinScript interpreter with the internal compile-time evaluator
• implement an IntelliJ IDEA plugin to highlight Reflekt query parts that should be replaced at compile-time
• embed Reflekt into the Kotless project
• support JS and Native targets

The intern is not expected to solve all these tasks, but rather work in the direction they are more interested in. Also, since the internship will be remote, all communication will be online.

In this project you will:

• Get to know the Kotlin compiler and its plugins (IR, compiler stages, and so on)
• Learn how to write plugins for IntelliJ IDEA
• Get experience writing a project in Kotlin
• Work in a team on a large and complex project

Requirements:

• Strong knowledge of Kotlin
• Basic knowledge of the Kotlin compiler, JVM
• Ability to write clear code
• Ability to read large amounts of code (Google will not help in this project :-) )
• Experience in this or related field would be an advantage

If you have any questions, please do not hesitate to contact anastasia.birillo@jetbrains.com

Researchers and practitioners in the ML4SE field often apply methods originating from the NLP domain. Indeed, code can be treated as a sequence of tokens, the same way as texts are sequences of words. This approach has been recently successfully applied in large-scale Transformer models such as Codex. However, source code has a richer inner structure compared to natural language: it can be represented as an abstract syntax tree, control flow graph, data flow graph, etc. These graph-based representations carry additional information about the code’s functionality, which can help models correctly understand code.

Graph representation of code allows the application of a different class of models – Graph Neural Networks (GNNs). Previous experiments in the field show that GNNs can outperform other models, including Transformers, when trained on the same datasets. However, they fall behind modern models pre-trained on vast amounts of data. For now, it is unclear whether large-scale pre-training might allow GNNs to outperform Transformer-based models.

Project description:

The goal of this project is to study how GNNs can be pre-trained on source code. The project consists of two major parts:

1. A tool for mining graph representations from source code in different languages
2. Implementation of GNNs for various ML4SE tasks and pre-training objectives

In case the internship is successful, we expect to publish the project results at one of the SE or ML conferences.

Sub-project 1. Graph mining:

We work on extending PsiMiner, a tool previously developed in our lab, to extract complex graph representations of code such as CFGs and DFGs. PsiMiner runs IntelliJ IDEA in headless mode to process source code, which allows using all the power of IDEs in source code analysis.

Currently, PsiMiner has performance issues when running subsequently on dozens or hundreds of repositories. Your goal in this sub-project will be to benchmark and speed up the tool in this case, which will allow the collection of truly large-scale datasets of graphs extracted from source code.

Requirements:

• Knowledge of Kotlin
• Ability to write clean code
• Willingness to dive into the development of plugins for IntelliJ IDEA
• Experience in concurrent programming would be an advantage

Sub-project 2. Pre-training of GNNs in ML4SE tasks:

We already started working on implementing GNNs for two ML4SE tasks – variable misuse prediction and identifier renaming. Your goal in this sub-project will be to benchmark different GNN architectures, select the ones most suitable for large-scale training, implement different pre-training tasks, and finally train a large graph-based model (and probably beat Transformers of comparable size).

Requirements:

• Knowledge of Python
• Experience with PyTorch/Tensforflow
• Knowledge of basic ML and DL
• Willingness to read academic papers
• Experience with PyTorch-Geometric and GNNs would be an advantage

If you have any questions, please do not hesitate to email egor.bogomolov@jetbrains.com

The goal of this internship is to prepare full-covered test cases for Qodana docker run configuration and automate test cases on integration or unit testing level. For the advance - to prepare quality gates plan and setup test execution as part of CI pipelines.

At a minimum, you should:

- Have coding experience with a modern language.

- Be ready to jump into Kotlin.

Our ideal candidate would also have experience with:

- Kotlin, Java, or other JVM languages.

- Docker, Bash, CI/CD approaches, TestOps.

The goal of this internship is to extend the existing UI testing framework: to prepare full-covered test cases for the Qodana UI and automate test cases on the E2E testing level. For the advance - to prepare quality gates plan and setup test execution as part of CI pipelines.

At a minimum, you should:

- Have coding experience with a modern language.

- Be ready to jump into Kotlin.

Our ideal candidate would also have experience with:

- Kotlin, Java, or other JVM languages.

- HTML, CSS, Selenium, Page Object pattern.

In order to bring our customers the smooth integration with their existing development flow we want to integrate the Qodana Cloud with common Git providers such as (GitHub, Gitlab, Bitbucket etc.).

The goal of this internship is to create a separate service for interaction with GitHub, Gitlab, Bitbucket and incorporate the service to the Qodana Cloud environment.The main goal would be to ensure an automated user onboarding from his existing GIT provider.

At a minimum, you should:

- Have coding experience with a modern language.

- Be ready to jump into Kotlin.

- Be interested in backend development.

Our ideal applicant is interested in the following languages/technologies:

- Kotlin

- Amazon Web Services

- Relational databases

While we already have good dev tools for integrating analytics in IntelliJ IDEs products family, we still need to provide better support for web applications that use our analytics platform (Space, YouTrack, TeamCity, etc). In particular, we need to analyze which data was sent from the web application after the analytics library was used and data collectors were implemented.

You will create an application that can function as a man-in-the-middle for dev instances of web applications and design UI to show, filter, and search through a log stream from a web application and forward received data to the actual endpoint.

Many products inside JetBrains use existing solutions to collect data (metrics, logs, and traces). One of such solutions is OpenTelemetry. We want to provide an adapter that can reuse existing integration of a client application with OpenTelemetry and transform collected data into our format.

You will implement such an adapter so it can be easily reusable and configurable. In case of success, there will be a possibility to try it on some of our existing products that currently use OpenTelemetry.

Pots and graphs are an essential part of data representation. And while we have them on the frontend side, there are some advantages to being able to do so on the backend: such as the ability to precompute plots for non-interactive data or embeddings in different notification systems like emails, blog posts, Slack bots, etc.

You will create a backend service that can render different types of plots / graphs / charts. This service should then be able to manage existing charts while avoiding unnecessary regenerations and store them on CDN, providing their location to other services.

Our team works very closely with the Data Analytics team, and they do their research on the same data that is used in our service. We want to provide data analysts with the ability to upload and share their research results through our system for convenience and representation unification.

You will add such functionality to the existing system. While the upload format is usually a simple CSV, there are a lot of technical nuances: data size, format validation, ways to store, manage, share upload.

The scheme and descriptions of collected data are an important part of the analytics platform. While we have current ways to work with it, there is always room for improvement. This is a research project where you aim to analyze the current approach of structuring and storing the data from different perspectives, outline the pros and cons and propose possible solutions as a result.

You will deep dive into the existing system, investigate problems, and prototype a different approach that could maintain the benefits of the current system and avoid its shortcomings.

Linker Scripts are written in the linker command language and instruct the linker how the binary parts of a program should be placed in the computer memory.
A prototype already exists, so you can get started on adding a new feature right away.

CMake is a build system for C, C++, Objective C, and other compilable computer languages. It is driven by scripts written with a dedicated language.

DTS is a language to describe peripheral devices and their register addresses. It is widely used in Linux kernel sources as well as in various frameworks related to embedded microcontrollers.