We’ve listened to the feedback we’ve received from our users, analyzed the most voted bug reports in our tracker, and refactored the installation layout to address most of the pain points.

To try out the Beta, make sure you’re using Toolbox App version 1.28, open Settings, and select EAP from the Update to list.

Read on to learn about the most important changes we’ve made in this release.

Installations and updates reworked from the ground up

Default installation directories

The Toolbox App previously installed tools in a custom directory with an ever-changing path. This is now a thing of the past. The default installation directory now conforms to your operating system’s guidelines and never changes.

Toolbox App 2.0 uses the following default directories to install tools:

• Windows: %LocalAppData%\Programs (FOLDERID_UserProgramFiles)
• macOS: ~/Applications
• Linux: ~/.local/share/JetBrains/Toolbox/apps (no change)

Please note that the Toolbox App can only install applications to user-writable directories (for example, the user’s home directory). In a future release, we’re planning to implement the ability to elevate permissions, which would allow installation to system-wide directories.

Permanent paths

In previous versions, the Toolbox App installed updates in the directory with a version number as its name, so each new version had a new path on the filesystem. Now it puts the new version into exactly the same directory, ensuring a permanent path for each tool.

Installing multiple versions of the same tool side by side is still possible. The Toolbox App will disambiguate them automatically, and you can set custom names in the tool’s settings if you wish.

Updates

The process of updating your tools is as easy as before. The only change is that, when you try to update a running tool, the Toolbox App performs all the necessary actions (downloading, unpacking, etc.) in the background, except for actually copying new files to the tool installation directory. After that, it enters the “Update Pending” state, which means that the only thing left is to wait until the tool stops running. As soon as you close the tool, its files will be replaced with their new versions, and then you can continue working.

This improves the compatibility of your installed tools with a number of OS and third-party applications, and has allowed us to eliminate different workarounds both in the Toolbox App and around it. Thanks to the permanent installation paths, pinned Start Menu items on Windows or docked apps on macOS are no longer invalidated after an update.

For IntelliJ-based tools, the default plugin directories are now used, which eliminates certain issues that used to occur during downgrading. We’ll explain all fixes in more detail in the public release blog post in several weeks.

Known issues

Unfortunately, this drastic change comes with several limitations:

• Instant rollback is temporarily not available.
• The tool installation directory can’t be changed (for now). However, if you specified a custom directory in the previous version of the Toolbox App, the new version will honor it (on macOS, it should be in /Applications or ~/Applications).
• The Start Menu shortcuts for your tools will be unpinned by Windows one last time (TBX-3331), and the Desktop and Taskbar shortcuts may appear “broken”, though that state can be easily fixed by clicking the shortcut. This happens only during the migration from Toolbox App 1.28 to 2.0.

Migration

In order to provide the improvements we are introducing, the Toolbox App will need to migrate any tools you have installed through its previous versions. After updating to version 2.0, it will run the migration, which can take a few seconds to several minutes, depending on the number of tools.

After the migration, all tools will be moved to their new locations, while all tool settings will be preserved during this process.

Although the migration cannot be undone, rollback to v1.28 is still possible. In this case, the Toolbox App will not lose your IntelliJ tools and their settings, but they will be displayed as manually installed (as, from the point of view of Toolbox App 1.28, they are no longer installed through it). Please let us know if the new installation layout does not work for you.

We’ve also introduced many other quality-of-life improvements in this version. Please see the full release notes for more information.

Please try the Beta and share your feedback with us in the comments to this blog post or submit an issue in our YouTrack issue tracker.

Thank you,
The Toolbox App team

Wear your love for coding on your sleeve, on a tote bag, or on your laptop. However you want to display your passion, the brand-new JetBrains merchandise store has you covered!

Shop JetBrains Gear

What we have on offer for you

We offer a wide variety of essential gear, like T-shirts, hoodies, stickers, and pins, as well as other JetBrains and product-branded apparel and accessories. 

All of our items are made with high-quality materials to ensure that they are long-lasting and enjoyable to use, and most of our clothing is made of organic cotton. We plan to expand our product line gradually after listening to the feedback from fans. Moreover, we’re already working on minimizing our environmental footprint, and will continue doing so. 

Our items are shipped worldwide (except for some countries) from a warehouse in Germany, with delivery terms and costs varying from country to country. Check out the store FAQ for more details, and don’t hesitate to contact the Customer Support team if you have any questions.

What’s next? 

The JetBrains store has a lot of quality gear, but it still has a lot of room to grow! While we are successful in creating software development tools you love, a fan shop is a different story. 

We are still learning what makes the perfect piece of merchandise and identifying the best process for getting the products into your hands. We want to ensure that your experience with the store is as satisfying as the tools you enjoy using. 

We’ve got an experienced managing partner and store provider, Brand Addition, who’s supporting us along the way, but we are also keen to know what you think.

Stock up on JetBrains gear from our shop and show it off in action! 

Share photos or videos of yourself using our items on social media, and be sure to tag @jetbrains or our products and add the #JetBrainsGear hashtag.

Shop JetBrains Gear

Let’s spread The Drive to Develop together! 📸

Your JetBrains team

The Developer Ecosystem Survey 2023 is here, and we invite you to take part in our research. To carry out a comprehensive, independent study of the software development ecosystem, we need your valuable insights and feedback. Please take the survey, which should take about 30 minutes, and share your developer story with us.

The survey is available in 10 languages, and you’ll have a chance to win one of the following prizes:

• MacBook Pro 16
• NVIDIA GeForce RTX 4090 graphics card
• iPhone 14 Pro
• $300 Amazon Gift Card
• JetBrains All Products Pack

Your input will help us and the community as a whole, so we encourage you to take the survey and share your thoughts. Please click on the link below to get started:

TAKE THE DEVELOPER ECOSYSTEM SURVEY

The more developers contribute to the study, the more representative it will be of the community. Share the survey with your friends and colleagues, and you’ll get a spot in an additional prize raffle. You’ll find the referral link on the last page of the survey.

As always, we’ll share detailed infographics with the survey results and insights on the latest tech and software development trends. In addition, we will provide anonymized raw data for your own research purposes. Finally, we’ll prepare personalized infographics for all participants that will show you exactly how you stack up against other members of the community.

So go on, take the survey, and help us understand the nature of things in 2023 in the developer ecosystem. Your voice counts!

Sincerely,

The JetBrains Research team

At a glance, here’s what you need to know about this release:

• JetBrains released Compose Multiplatform for iOS as Alpha, meaning it’s ready to be used in experiments and toy projects. Try it out, and help shape the future of shared mobile user interfaces with Kotlin!
• Compose Multiplatform uses APIs that are already being used for UI development on Android. This makes it very easy for developers with a background in modern Android development to quickly get up and running with Compose Multiplatform for iOS. It also allows newcomers to base their learning on established concepts and best practices.
• As an Alpha release, Compose Multiplatform for iOS still has many areas that are works in progress. We rely on the community to help inform and shape the future of shared Kotlin user interfaces, so give the technology a try and share your feedback!

Get started with Compose for iOS

JetBrains first announced Compose Multiplatform for iOS at KotlinConf 2023. For a detailed look at Compose Multiplatform for iOS in action, watch the recording of the announcement talk “Compose Multiplatform on iOS” by Sebastian Aigner and Nikita Lipsky:

Pushing Kotlin Multiplatform beyond business logic

With Kotlin Multiplatform, Kotlin developers already have a tried-and-tested approach to code sharing. It allows you to share business logic between different platforms without having to give up access to platform-specific APIs and features – an approach that has been validated by many applications in production, with more and more companies leveraging it to get rid of unnecessary duplication of logic in their applications.

But one part of the Kotlin Multiplatform story was missing: a solution for when you don’t want to build and maintain separate user interfaces for each platform you target. There are a multitude of reasons why this may be the case for you: You may lack the resources or people to provide implementations that are tailor-made for each target platform. Or you might find yourself in a situation where you need to get your application into the hands of users as fast as possible, with quick iterations, and can’t spend time manually keeping two or more UI implementations in sync.

Compose Multiplatform addresses this. It gives you the option to implement your user interface once and then share it across target platforms – whether that’s the typical mobile case of sharing between Android and iOS or includes further platforms like desktop or web.

Built on Jetpack Compose

Compose Multiplatform builds on top of Jetpack Compose from Google, the recommended UI framework for modern Android development, which is 100% Kotlin. The team at JetBrains that develops Compose Multiplatform collaborates with Google and regularly upstreams changes to the Jetpack Compose repositories.

The APIs in Compose Multiplatform are the same ones that have already been tried and tested in Jetpack Compose. That means developers who have experience writing modern Android user interfaces using Jetpack Compose can transfer those skills directly to write a shared user interface with Compose Multiplatform, targeting iOS and beyond.

To illustrate the fact that the APIs really are the same, take a look at this example snippet of Compose Multiplatform code that animates the visibility of an image whenever the user presses a button:

@Composable
fun App() {
    MaterialTheme {
        var showImage by remember { mutableStateOf(false) }
        Column(Modifier.fillMaxWidth(), horizontalAlignment = Alignment.CenterHorizontally) {
            Button(onClick = {
                showImage = !showImage
            }) {
                Text("Toggle image")
            }
            AnimatedVisibility(showImage) {
                Image(
                    painterResource("compose-multiplatform.xml"),
                    "Compose Multiplatform Logo"
                )
            }
        }
    }
}

If you have worked with Jetpack Compose before, most of this code should be familiar to you: Compose Multiplatform allows you to use the exact same APIs that you would use for modern Android development, including state management, layout, and even animations. For tasks that are system-specific in Jetpack Compose, like loading resources, Compose Multiplatform provides convenient alternatives that work on all platforms – like the painterResource function in the above snippet.

As you can see, this code runs on both Android and iOS, with consistent results:

On iOS, Compose Multiplatform user interfaces are rendered via a canvas implementation based on the graphics library Skiko. On Android, Compose Multiplatform is Jetpack Compose. This means that if you ever decide to move your application to platform-specific UIs, you can continue using your Compose Multiplatform application on Android without any drawbacks and without having to throw away the code you’ve written.

Built on Kotlin Multiplatform

Apps built using Compose Multiplatform are Kotlin Multiplatform applications, meaning they can use the same established mechanisms to access platform APIs such as sensors, preferences, data storage, cryptography, and others. They can also make use of the ever-growing ecosystem of Kotlin Multiplatform libraries that provide anything from database wrappers to cross-platform wrappers for SDKs. You can also, of course, continue to use Kotlin Multiplatform independently of Compose Multiplatform to share business logic, networking, and other abstractions.

Interoperability with SwiftUI and UIKit views

Real-world applications need access to device-specific capabilities, and in many cases, the UI layer is no exception: Whether it’s embedding a browser or playing back video, you may find yourself wanting to access the built-in functionality that iOS provides to enrich your users’ experience.

For these situations, the Alpha version of Compose Multiplatform comes with a prototype for two-way interoperability on the UI layer. By using UIKitView, you can embed complex platform-specific widgets like maps, web views, media players, and camera feeds within your shared user interface. In the other direction, via ComposeUIViewController, you can embed Compose Multiplatform screens in SwiftUI applications, helping you gradually adopt Compose Multiplatform in iOS applications.

Working on an excellent user experience

Compose Multiplatform for iOS is currently in Alpha, which also means there are a number of areas that are still works in progress. Providing an excellent user experience across multiple platforms is a subject that requires great care, and the whole team wants to make sure to address all aspects necessary to make Compose Multiplatform applications feel comfortable and natural, no matter where they are used. This starts from the most basic interactions, like gestures and scroll physics, which define the fundamental feel of an application. It extends further to navigation principles and transitions, as well as complex interactions like text selection, input management, context menus, and similar interactions.

We also recognize how important it is for Compose Multiplatform applications to provide solid accessibility integrations, as well as respect user choices, and we are committed to providing solid integrations with the underlying iOS mechanisms – integrating with everything from the system’s text-to-speech functionality to the zoom and contrast preferences that users have set on their devices.

Obviously, this is a diverse and broad set of focus areas. We want to give all of them the level of care needed to ensure Compose Multiplatform on iOS provides the best user experience possible. In doing so, we want to be sure we’re putting your needs first, and we welcome your feedback!

We’re also aware that absolutely smooth performance, even on high refresh rate displays, is a major factor in providing a great user experience. As such, the Compose Multiplatform and Kotlin/Native teams are working together closely to improve the performance of shared user interfaces on iOS.

Theming Compose Multiplatform for iOS

Because Compose Multiplatform on iOS uses canvas-based rendering, both iOS and Android applications look the same by default. Currently, Compose Multiplatform provides Material and Material 3 widgets out of the box on all platforms. These are the same widgets that you may already be familiar with from Android applications. Using the builtin theming functionality, you can adjust the look and feel of these widgets to reflect your branding, either consistently across platforms or with custom platform-specific themes.

Of course, a key question for a cross-platform UI framework is to which degree elements should mimic the look and feel of its target platforms. At the current stage, the JetBrains team has not yet made any decisions about providing native or common-looking UI elements. Since this is a key part of the Compose Multiplatform user experience, we don’t want to make decisions on this without first gathering feedback from the development community, and we welcome you to share your thoughts and opinions with us.

Try Compose Multiplatform for iOS yourself!

We hope you’re excited to give Compose Multiplatform for iOS a try! As we’ve discussed, there are a lot of things that are still works in progress, but there are also many that already work well and are ready for you to play around with!

We provide a number of different ways for you to get acquainted with the Alpha release of Compose Multiplatform for iOS, including sample applications and project templates.

Get started with the template

The easiest way to get started writing your own applications targeting Android and iOS with Compose Multiplatform is to use the official GitHub template, which comes with its own tutorial to get your first Compose Multiplatform app up and running.

Get started with Compose for iOS

Explore Compose for iOS with demo applications

A good way to explore how a new technology is used is to look at some samples. We have prepared a number of example projects that demonstrate Compose Multiplatform on iOS and its other targets. You can find them in the Compose Multiplatform repository.

Explore sample projects

Other sample projects like the Kotlin Multiplatform Mobile Production Sample now feature a branch that contains a UI implementation based on Compose Multiplatform, allowing you to compare differences and similarities between sharing only the business logic between apps, and sharing the UI layer of the application as well.

Share your feedback!

Compose Multiplatform on iOS is in Alpha, and we want to evolve the technology based on your needs.

Help us help you by reporting problems, telling us about APIs that you feel are missing, and requesting features you’d like to see. You can do all of this in the project’s issue tracker.

If you want to talk to the team behind Compose Multiplatform or other developers, we also invite you to join the discussion on the Kotlin Slack. In the #compose-ios channel, you can find discussions about Compose Multiplatform for iOS. In #compose you can discuss general topics related to Compose Multiplatform and Jetpack Compose.

We’re looking forward to seeing what you’ll build next with Compose Multiplatform!

See also

• KotlinConf 2023: A Look at the Opening Keynote
• Compose Multiplatform 1.2 Is Out

Download now

As announced earlier, support for multiple JetBrains Accounts has been discontinued. Please link your emails to a single account instead.

Community translations

Not one, but two new Community translations contributed by our users have been added to the list of available languages under the Toolbox App Settings. We want to thank Raman But-Husaim for the Belarusian translation and David D’Amico for the Italian translation!

If you’d like to translate the Toolbox App into a language that is not yet available, we would be happy to help make this happen. Contact the team via YouTrack or email.

This update is smaller than usual as we’re continuing to work on a major new version to be released later this year. Stay tuned!

Yours,
The Toolbox App team

IntelliJ-based IDEs

You will find the following new features available across most of the IDEs:

• The new UI has been updated to provide you with a more polished and seamless experience. It is still in Beta and is available as a setting.
• A number of new features make working with Git, GitHub, and other version control systems easier, including an improved Branches popup, background commit checks, and more.
• Web development improvements include new Astro framework support and enhancements for Vue, React, and Angular users.
• We’ve added support for major features from the upcoming TypeScript 5.0.
• New features have been added to make working with Docker easier, including a merged log view from all Docker Compose containers and support for Azure Container Registry.

There are many more product-specific changes. See the summaries below and dive deeper to learn more about the products of your interest.

IntelliJ IDEA 2023.1 is now available with a range of new features and improvements. The IDE’s new UI has been updated to provide you with a more polished and seamless experience. The latest performance enhancements have resulted in faster Maven imports and the earlier availability of IDE features when opening projects, as well as a streamlined commit process thanks to background commit checks. IntelliJ IDEA Ultimate now supports navigation for Spring Security matchers and request mappings. These are just a few of the improvements in v2023.1 designed to streamline your coding experience and boost productivity.

PyCharm 2023.1 brings the long-awaited support for remote Jupyter notebooks! Now you can connect to, copy, paste, modify, and debug remote notebooks from inside the IDE. The new version comes with improved code review workflows and better syntax highlighting in Quick Documentation.

DataGrip 2023.1 is a quality-focused release; it adds no new features but fixes lots of annoying bugs.

Rider 2023.1 improves support for C#, including a set of inspections to optimize and speed up your work with different types of collections and more adjustable ways to introduce null checks in your code. Game development using Rider is bolstered by the introduction of support for Unity’s Data Oriented Tech Stack (DOTS) and Unreal Engine 5.2, including the recent updates to the Blueprints file format and support for Godot 4. There are also some enhancements to Version Control tools and working with Docker, as well as a bunch of improvements to the new UI and the overall user experience.

RubyMine 2023.1 is packed with Rails 7 and Ruby 3.2 support, new UI updates, faster code completion, decreased memory consumption, improved gem synchronization on WSL, easier navigation and working with shared contexts and examples in RSpec, and enhanced Docker integration.

GoLand 2023.1 introduces the vulnerability checker, better navigation in gRPC code, and Rename refactoring for generic receivers. You can now run scratch files with non-standard-library packages and quickly convert raw string literals to double-quoted ones and vice-versa.

CLion 2023.1 brings a solution for package management, takes your debugging experience to the next level, helps with QML coding, and includes a host of improvements to the new UI.

PhpStorm 2023.1 is a major release that includes updates for the new UI, 3v4l.org integration, better performance, DFA in the debugger, support for multi-composer.json projects, improvements for PHP generics, and much more.

WebStorm 2023.1 comes with Astro support, TypeScript support for Vue template expressions, Tailwind CSS configuration, full IDE zoom, refinements to the new UI and version control integration, and more.

.NET tools and VS extensions

ReSharper 2023.1 improves support for C#, including a set of inspections to optimize and speed up your work with different types of collections and more adjustable ways to introduce null checks in your code.

These updates also made it into Rider 2023.1, in addition to some enhancements to Version Control tools and features for working with Docker, visualizers for string variables in the debugger, and a bunch of UX/UI improvements. Game development using Rider has been bolstered by the introduction of support for Unity’s Data Oriented Tech Stack (DOTS) and Unreal Engine 5.2, including the recent updates to the Blueprints file format and support for Godot 4.

ReSharper C++ 2023.1 brings updates for C++20 and C++23 features. It also introduces Call tracking for incoming calls and macro substitution previews in tooltips and Quick Documentation popups.

The standalone version of dotTrace is now available on Linux and macOS.

That is it, but the blog post only scratches the surface of the massive release. We hope these updates make your work more enjoyable and help you be even more productive.

We recommend installing and updating your JetBrains tools via the free Toolbox App. If you do not have it yet, download the app and manage your developer tools with ease!

Your JetBrains team

The raw data is accessible in two formats: csv with raw data and a Jupyter notebook with examples of analysis. 

The notebook demonstrates the basic analysis of the survey. It shows the structure of the data, gives some analysis examples, and provides the main functions for conducting your own analysis.

Open analysis example in Datalore

The directory with raw data contains data in wide and narrow formats, survey questions, survey logic, a license, and a table with a short transcript of names. The report and dataset is public and shared under the license. Its contents may be used as long as the source is appropriately credited.

We have taken all necessary measures to ensure that the data is accurate, complete, and anonymous. We have also ensured that any sensitive or personal information has been appropriately de-identified or removed to protect the privacy of study participants. All open-ended fields have been removed, and response options that collected fewer than 15 responses have been incorporated into the Other category.

We’d like to express our gratitude to everyone who contributed to this research and helped us and the community to expand our knowledge of the industry.

Dig into the data, and don’t forget to join our JetBrains Tech Insights Lab to take part in our future studies!

If you have any questions or concerns regarding the data, please contact us at surveys@jetbrains.com.

Thank you for your interest in our research,

The JetBrains Team

We’ll be taking part in GDC 2023 with an in-person booth during the expo days, March 22–24. Here’s what you’ll be able to do if you stop by:

• Visit the Ask for a Demo zone. Our experts will be at the booth and eager to tell you everything you need to know about our products. Drop by and ask any questions you may have about Rider, TeamCity, Space, or YouTrack. On top of that, you’ll have the opportunity to learn useful tips, find out about our future plans, or just chat with our team.
• Try the products you are the most interested in at our self-demo stations. Our experts will be happy to help you learn more about the capabilities and functionality of JetBrains tools.
• Enter our Presentation zone to learn more about game development with JetBrains tools. Each demo talk lasts about 20–30 minutes. We will discuss Rider for Unity and Unreal Engine dev tips, building games with TeamCity, using RiderFlow to better manage your level design, DOTS technology for Unity developers, and more. Check out the topics below and review the schedule at our booth during the event.
• Share your own expertise by participating in a Unity vs. Unreal Engine survey-battle and a Game Development pipeline survey. Fill out a survey to grab some JetBrains swag!
• Want to talk about a potential partnership? Interested in what JetBrains does in general? Stop by our booth and ask any type of question!

The technologies and topics you can learn about at our booth:

• Creating games with Unity. From effective scene management to developing game logic, you’ll learn how to benefit from the brand-new DOTS technology with Rider.
• Creating games with Unreal Engine. Learn how to be more effective with Rider, including tips for working with Blueprints, migrating code from the main game module to a plugin, and much more.
• Creating games with Godot. Find out whether Rider can help you here as well!

• Building a Unity iOS game using TeamCity and AWS. Learn how to build, run, and grow your game with TeamCity and AWS.
• Using JetBrains Space to support your game dev workflow with Git hosting, quality gates, design documents, and more.
• Rider and TeamCity integration with Perforce VCS. We’ll show you how Rider and TeamCity integration works with Perforce VCS. There is no need to use any external utility, since Rider supports it completely.
• Manage projects and tasks with JetBrains YouTrack to make your GameDev truly co-op.

You can find us at the South Hall of the Moscone Center in San Francisco:

See you there,

Your JetBrains team

In this post, we’ll look at why and how we implemented distributed testing for our Remote Development and Code With Me tools.

Why we need distributed testing for our IDEs

Most of the IDEs we develop at JetBrains are based on the IntelliJ Platform. To ensure their quality and functionality, we conduct thorough testing. Historically, we have divided our tests into two categories:

1. Unit tests, based on the junit or testng framework, are the most common way to test logic. In these tests, we start the IDE in headless mode – without a UI and with some overridden components. The IDE runs inside the unit test process, allowing us to easily write test code and debug it afterwards. 
2. UI Scripting Tests are designed to test the user interface of the IDE. These tests start a separate IDE process with a UI and a real component container and communicate with it using a command system. There are relatively few of these tests, as they take a significant amount of time to run and are more difficult to write. To create these tests, a special command must be implemented within the application and can only be called by name.

These testing methods have been sufficient for developing and maintaining the quality of the IntelliJ Platform for many years. However, with the introduction of new products such as Code With Me and Remote Development, new testing challenges have emerged. These products allow you to connect to another IDE running on another computer.

• Remote Development allows you to run an IDE on a remote machine, usually in headless mode, and connect to it using a thin client on a local machine.
• Code With Me assumes that you already have an IDE with an open project and enables you to connect to it from another computer to collaborate on the project. It supports multiple participants.

In both scenarios there are two or more IDE processes running simultaneously. None of the existing test frameworks support this scenario, so we had to develop a new one!

Building a new testing framework for distributed IDEs

To effectively test our Remote Development tools and Code With Me, we needed to create a testing framework that would give us the ability to:

1. Run multiple IDE processes in various environments, possibly even on different machines. A typical test case is running a server-side IDE on Linux and having the client connect to it from Windows.
2. Run IDEs in both UI and non-UI modes.
3. Write test code easily.
4. Debug test code efficiently.

In our scenario, it is not possible to run IDEs within the unit test process. However, we still want to be able to write and debug tests as easily as possible.

We already have a special RD protocol in place, which was initially developed for Rider to connect the ReSharper backend process to the IntelliJ Frontend process. Later it was also used in Code With Me and then in Remote Development to connect the IntelliJ backend to the IntelliJ Thin Client. Why not use the same protocol here as well? It is a proven solution that can be easily integrated into our test framework.

This is our principal architecture diagram: 

The basic unit test process, either junit or testng, is initiated by the IDE. This unit test process will spawn other IDE processes – one for the server, and others for clients. For Remote Development, there will be a single client. However, for Code With Me there could be multiple clients. All of them are connected to each other and to the unit test process via the RD protocol.

The new test framework has been named the “Distributed Test Framework” as it is designed to run tests that are distributed across multiple processes or machines.

What does a simple test in this distributed test framework look like? Let’s take a look at an example:

class Test : DistributedTestBase() {

  @Test
  fun testEditor() {
    startServerAndClient(...) { server, client ->

      server.perform {
        // open an editor        
      }

      client.perform {
        // assert editor is opened
      }
    }
  }
}

The test consists of multiple perform calls that correspond to the different IDEs being tested. Each call uses the regular IDE API, but the code is executed in other processes. How does this work?

1. The startServerAndClient method runs two IDE processes by building a classpath. It creates the default IDE classpath from all core modules and then adds specific test jars to it. 
2. The testing process subsequently establishes a connection to them using the RD protocol and waits for the IDEs to be fully loaded.
3. Next, it dispatches the test class and specific test method to be executed to all of the connected IDEs.
4. The IDEs create a test class (it is already present in the class loader) and execute the specified test method.
5. Then a test executes the specified test method on its own.

The key is the perform method. It is invoked multiple times – once by the unit test process and again by the IDE processes. When it is called by an IDE process, it stores the action in a queue. In the unit test process, it sends a signal to the corresponding IDE, which then proceeds to execute the requested action from the queue. The overall structure of the method can be summarized as follows:

protected fun AgentConnection.perform(action: AgentContext.() -> Unit) {
  if (agentDescription != null) {
    // That means now we are just playing the test inside agent, so we should not perform this action
    //  but just put in into the agent queue
    if (this.agentId == agentDescription.info.agentId) {
      agentDescription.queue.add(AgentAction(action))
    }
    else {
      // Just ignore, this command is intended to other agent
    }
    return
  }

  // We are running test in a test process so send command signal to the corresponding agent
  val connection = this as PhysicalAgentConnection
  connection.scheduler.executeSync { connection.session.runNextAction.sync() }
}

This process can be illustrated by the following diagram:

This framework allows you to write code for multi-process testing as if it were for a single process. But what about debugging? Modern IDEs are equipped with advanced features and can attach a debugger to the unit test process. However, it may not be possible to set breakpoints within the perform methods as they are executed in separate processes, and the IntelliJ debugger does not have the capability to resolve this issue.

Even powerful IDEs like IntelliJ IDEA do not have the capability to start debuggers for processes started by the IDE. However, as IDE developers, we can solve this issue!

We have developed an HTTP handler that listens for requests and attaches a debugger to the requested process. We have incorporated it into devkit, a specialized section of code that enables IntelliJ developers to work more efficiently.

In the test framework, we execute the following code immediately after the IDE process is started. This ensures that the debugger will be connected to the newly started process, allowing for debugging capabilities while the test is running:

 private fun attachIDEToProcess(debuggerPort: Int): Boolean {
    val url = URL("http://localhost:63342/debug/attachToTestProcess")
    val connection = url.openConnection() as HttpURLConnection
    connection.requestMethod = "POST"
    connection.useCaches = false
    connection.doOutput = true

    DataOutputStream(connection.outputStream).use { it.writeBytes(debuggerPort.toString())  }
    try {
      return connection.responseCode == 200
    }
    catch (ex: Throwable) {
      return false
    }
  }

The debugger will only be able to connect to the specified port if it has already been opened by the JVM. Therefore, we start our IDEs with the following command line argument to ensure the port is open:

-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=$port

Once the unit test process and IDEs have been initialized, we can set breakpoints and debug multiple processes as if they were a single process! This requires no additional effort from the developers – it works seamlessly out of the box:

Conclusion

By introducing this innovative test framework, we have revolutionized the way tests are written and debugged for our distributed applications. The framework is designed to make the process as seamless and effortless as possible for developers.

Sometimes, investing a little time into improving tooling can have a significant impact on the productivity of the entire team. In this case, it took only 2-3 days of work to create this framework, and now our team is able to save hours of time, be more confident when writing these kinds of tests, and focus on delivering high-quality code.

Want to join our Code With Me and Remote Development team and build a distributed IDE with us? We’re hiring!

You know JetBrains Academy as the learning platform operated in collaboration with Hyperskill. But when we chose this name in 2019, we thought of JetBrains Academy as more of an umbrella concept. We envisioned a place where we could share our drive to make a dent in this world with educators and lifelong learners worldwide. This vision shifted as we needed to narrow our focus down to the early product phases. We never stopped developing our EduTools plugin, and we’ve launched multiple educational courses on JetBrains Marketplace over the years. Now that, more than a million passionate learners and educators worldwide use our educational products in one way or another, it’s time to bring this more comprehensive JetBrains Academy back and unite all our educational products, programs, and efforts under one brand.

Please welcome the new JetBrains Academy – a place for learning and teaching computer science your way!

Get Started

What JetBrains Academy offers

Project-based learning with JetBrains Academy on Hyperskill

JetBrains and Hyperskill will continue working together. Hyperskill believes in project-based learning, active learning, and extensive practical exercises. These principles correlate with JetBrains Academy’s values, so it’s no wonder that we host our content on the platform and augment it with our learning-in-the-IDE approach. While most of the learning process takes place online on Hyperskill, some parts of the practice are accessible only in JetBrains IDEs.

Our partnership with Hyperskill enables you to learn computer science by creating real-world applications. With no prior experience in programming, you can start developing games, chatbots, algorithms, or even neural networks. The more projects you work on, the stronger your developer portfolio gets, and the more prepared you become for a job interview and a career in computer science. As an educator, you can use JetBrains Academy’s learning materials to keep up with the constantly changing technologies.

What has changed?

On the Hyperskill platform, JetBrains Academy will now focus on being a content provider, while Hyperskill will evolve and become a learning platform with its branding, subscription plans, and more content from other providers in the future. At the same time, JetBrains Academy will expand its brand to include other learning and teaching approaches in addition to the project-based approach.

I have a subscription to JetBrains Academy. How will these changes affect me?

The changes will not affect your Hyperskill account, access to JetBrains Academy content, or your learning progress. Your subscription plan will also remain active and won’t be changed. With your current subscription, you will keep access to all the content available on Hyperskill, regardless of the content provider. You can also expect more learning content from other providers in the future.

You can manage your subscription on the Hyperskill subscription page the same way you’ve been doing so far.

Will this affect prices?

The pricing remains the same for now. Hyperskill offers both personal and organizational subscription plans that give you full access to all the platform content, including the content provided by JetBrains Academy. You can also expect more subscription plans to become available on Hyperskill in the future.

Learn more about the pricing.

JetBrains Academy interactive courses right inside IDEs

For learners

With JetBrains Academy, students can take guided programming courses right inside JetBrains IDEs. You can choose between JetBrains courses and those from other educators. The added benefit of this is that learning right in an integrated development environment immerses you in the daily routine of professional developers and thus prepares you for the challenges of your future career.

Choose an interactive IDE course on JetBrains Marketplace and start learning.

For educators

JetBrains Academy can help complement your school classes or corporate teaching, or it can be a standalone solution to base your online education efforts on. With its course creation functionality available through JetBrains IDEs, you can share your programming knowledge by using the professional development tools you already know. You can share the courses you create, either privately with your students or publicly on JetBrains Marketplace. Once your course is published on Marketplace, you will be able to view its statistics, manage information about the course, and check its ratings and reviews.

Create and share your interactive course.

JetBrains Academy university programs

If you prefer studying offline, in a classroom setting with your peers, and learning directly from industry experts, you’ll be happy to know that JetBrains Academy now offers Data Science and Software Development programs at Constructor University in Bremen, Germany. In particular, our Bachelor program provides 3 tracks – Programming Languages, Software Engineering, and Machine Learning. A Master program is currently being developed as well. We are also working to partner with other universities, so you can expect more academic programs to come to JetBrains Academy in the future.

Apply to the program.

What’s next

We’re immensely grateful to you for being a part of our journey! You are the reason we’re here today and continue to move forward. We hope our new vision for JetBrains Academy will help you find your path to learning or teaching computer science and help you enjoy the process even more.

We’re eager to enhance JetBrains Academy with more educational approaches and tools, so that it inspires you in even more ways and becomes your preferred place for learning and teaching computer science. With the main focus on learning-by-doing, we want JetBrains Academy to integrate with third-party learning platforms and to enrich the learning and teaching experience with professional tools and computer science expertise. We hope that these steps will help JetBrains Academy become an even more valuable educational resource for individuals, businesses, educational institutions, and the whole computer science community.

We love hearing from you! Please share your feedback or ask questions in the comments section below. You can also tag us on Twitter or Facebook.

Your JetBrains Academy team

As usual, we are excited to present a picture of the coding community with the latest trends in programming languages, technologies, tools, and frameworks. You can also get a glimpse into the daily lives of developers.

The report is based on the responses from 29,000 developers from more than 38,000 who participated in the survey and provides insights on a wide range of topics that describe the developer ecosystem.

This is the sixth iteration of our annual survey, and each year it becomes more comprehensive. The report shows about 500 charts organized in 31 sections divided by topic and accompanied by interesting facts. This year we introduced new sections on Data Science, Remote Development, and Mental Well-Being, not to mention new questions throughout the report.

Here are some of the key findings from the report:

• JavaScript is still the most popular programming language and still hasn’t been overtaken by TypeScript, the usage of which has almost tripled over the last 6 years.
• Technologies that developers find promising: AI/ML, Rust, JavaScript, Go, Kotlin, and Blockchain.
• Programming languages people would like to adopt: Go, Rust, Kotlin, TypeScript, and Python.
• The programming languages that are losing their popularity: PHP, Ruby, Objective-C, and Scala.
• Working from home is still a choice for the majority of developers, and 76% choose to work primarily in a home office.
• 50% of developers practice remote collaborative programming.
• 69% of employed survey respondents are satisfied with their job, but only 57% are satisfied with their salaries. The most important component of valuing a job is feeling that you can achieve something.
• 73% of developers have experienced burnout at some point in their careers.
• The most popular way of getting a job is a referral from a friend. 30% of survey respondents got a job this way.
• Dogs are slightly more popular than cats among developers! Woof!

We encourage you to take a look at the report and share your thoughts with us.

EXPLORE THE STATE OF DEVELOPER ECOSYSTEM 2022 REPORT

Thank you to everyone who participated in the survey and helped make this report possible. We hope you find the results as interesting and informative as we do!

Would you like to participate in next year’s Developer Ecosystem Survey? If so, join our research panel! You’ll also be first in line to participate in our many other surveys and research activities, such as interviews and UX studies. Our panelists are eligible for cool prizes, too!

Roman: Good morning!

Pasha: Morning! Though 10:30 AM is not actually morning for me. I’m generally an early bird, but in December I have one more reason to get up early. Every day, I solve programming puzzles in Advent of Code. Do you know what that is?

Roman: There’s a hint in the name, but you’d better tell me.

Pasha: This year, more than a hundred thousand people are participating. Every day, new programming challenges are posted on the website, primarily in mathematics and algorithms. You can solve them in any programming language and submit your solutions. The task for the day is the same for everyone, but the input data, against which your solution is checked, is different for each participant.

Roman: And why wake up early?

Pasha: In my time zone (GMT+1), a new task is published at 6 AM, and ideally it has to be dealt with around the same time. To be honest, I’m not enough of an early bird to start it at 6 AM, but I’ll do my best to get it done as early as possible. And since many of my peers are in Europe too — the competition is still tight!

Not to mention that I enjoy solving problems before getting down to work. It sort of gets me in a working mood.

Roman: Great! So there you are, in the right mood, and your workday begins. What do you do? 

Pasha: I work as a developer advocate on the Big Data Tools team.

My job is about making users awesome. There is an amazing book called Badass: Making Users Awesome about how we should work to make people productive and happy at work. 

I try to educate people on various topics in the hope that someday they will talk to me, and I will be able to listen to them and say, “Yes, we can implement this for you in Big Data Tools.”

The phenomenon of developer advocacy appeared in response to the fact that IT people don’t buy products that are advertised in traditional ways. They want to understand why the product exists. Internally, advocacy is often a kind of sales – people come to their managers and tell them which tool they want to use. 

I’d like to believe that someday our Big Data Tools will become the default tool. 

Roman: The default tool for whom?

Pasha: Big Data Tools is a plugin for data engineers…

Roman: Let me stop you right there. From your point of view, who is a data engineer? What kind of profession is it?

Pasha: I really like to make an analogy with plumbers when I talk about data engineers. 

We always have sources and receivers, we can collect data, transfer it, pour it back and forth, and perhaps transform it with every operation. It can be a complex system, like plumbing or sewage. And along the way, we can say how to lay pipes correctly and in which facilities we should store data.

In other words, data engineers are people who know how to handle data. At the same time, they normally don’t extract any business value from the data, neither analytical nor scientific. For them, data is just a raw material that needs to be prepared and handed over to other experts.

Roman: OK, let’s assume this is clear. What’s the problem with tools for data engineers?

Pasha: I think that Big Data is still too young a field. That’s why we are seeing a growing number of specializations, deepening knowledge in particular sub-fields, and that’s why we have data scientists, data analysts, and data engineers.

Sometimes, they distinguish between a lot of different kinds of data engineers. Often people are engaged in one very specific task which eats up all eight hours of their working time.

This isn’t cool. I believe that people should be pentagon-shaped. It’s when all of your knowledge is deep, and only one point of the figure, in my case it’s Java, is a little deeper than everything else.

Roman: Why doesn’t it work that way in Big Data?

Pasha: The field is not mature enough.

The tooling is still poor, and we need a lot of people who know how to work with different tools. A lot of things just haven’t gotten around to being done yet. For example, there is Apache Spark, a very popular tool. And, let’s say, we stumble upon a bug.

Roman: Our bug or a Spark bug?

Pasha: Our bug. In our code. If we have a bug in the backend of a standard enterprise application, we usually have an understandable stacktrace. We can try debugging or using debug prints – these are working methods. 

But there’s no way you can debug Spark. And you can’t do debug prints – you have too much data and won’t find what you’re looking for in the debug output. You can’t even download this output. So you have to look for the bug analytically, which isn’t always a trivial task.

Roman: You mean the only thing you can do is read the code?

Pasha: Sort of. I really hope that one day JetBrains will make a debugger for Spark. I have an idea how to approach the task, and we’re considering it.

And I’ve only mentioned Spark, which is the most advanced of all the tools. There is this picture, State of BigData Ecosystem, with more than a thousand technologies. There are so many because none of them solves the problem perfectly.

Roman: But, as a business, we don’t want to wait until the ecosystem evolves. We want to be able to act right now, even though the field is immature. How do you develop Big Data Tools?

Pasha: Actually, the fact that the industry is immature is to our advantage. There are so many tools on the market, they are so diverse and achieve such different goals, that we can integrate all of them (ultimately) and solve all the problems. When industry matures, the number of tools will get smaller, but we will still support these tools and thus we’ll support most data engineers.

Roman: Or we could make our tool the perfect tool?

Pasha: That’s possible, but there’s a problem. At the moment, the no-code and low-code paradigms are becoming increasingly popular in data engineering. 

If by chance the perfect tool happens to be a no-code tool, there will simply be no place for us. We make great IDEs, but visual programming has never been our strong suit. We have a different focus.

Therefore, beating a tool originally designed as no-code on its home field seems unrealistic.

For now, we’re doing well in the absence of a universal tool, where we can integrate a million different technologies into our solution. We can say, “No matter what you’ve got under the hood, you can work with it in our IDEs, and we will provide a consistent user experience.”

Roman: Could you give an example?

Pasha: For example, we’ve recently added an integration with Amazon EMR. It is not only a MapReduce, but a cluster with a Spark-like UI. This work was finished and rolled out, as well as many exciting things like Tencent CLoudand Alibaba Cloud integrations..

Our next step could be to support the Google Data Proc to have feature parity between major cloud vendors.

Then there is integration with Zeppelin, which allows you to work with notebooks without having to leave the IDE. A lot of work has been done here. With a bit of luck, we might be able to reuse part of this work to support other notebooks.

And the work on massively requested features — dbt support and Avro Schema Registry — is in progress too.

Roman: What made this integration so hard to implement? You have a Zeppelin notebook, which can be located anywhere, and you need to connect to it?

Pasha: Connection is no big deal. The hardest part was to make a Zeppelin editor because it’s not just about showing a web interface in the IDE. It is a full-featured editor with lots of cells where every cell is another editor. It renders HTML for you and all sorts of settings.

We’ve also made ZTools. It’s a tool that shows you a scheme of your Spark data frames. We know this scheme and can offer autocompletion for columns in Spark-SQL. The database doesn’t exist in reality, but we can create a synthetic Spark database, autocomplete column names in your code, and check whether the arguments are passed correctly.

Roman: And how do you choose and prioritize the directions for Big Data Tools development? How do you decide what needs to be done first?

Pasha: I do the search, but not prioritization. But I can tell you how I do my research.

I hang out on data engineer forums, like in the international data engineers Slack channel. There are not many members, around a thousand people, but it’s interesting to read the questions that they ask.

These questions can’t always be answered, but they help me understand the trends. Then I go to our team lead, Ekaterina Podkhaliuzina, and tell her, “There is this tool, and people have been showing a lot of interest in it; perhaps we could help them.” 

I have some kind of a threshold in mind which helps me judge whether a tool is popular. For example, a couple of days ago I realized that about DBT (Data Build Tool), which allows you to describe your data model in YAML. In a nutshell, it allows you to create data marts.

It is extremely popular now, and perhaps we’ll be able to come up with something to support it. Since we have connectors to everything, we could provide coding assistance for SQL inside the models. 

Roman: In order to follow what’s happening, you have to have some understanding of everything, right?

Pasha: I like the idea of bringing domains together. Anton Keks, a great speaker and person, in his talk “The world needs full-stack craftsmen” describes the need for artisans who can do any job. This resonates with me a lot because it fits well with my experience. I can do almost any job, except for something very science-intensive, like compilers or advanced mathematics. I can develop frontend with React or write databases – these are the things I’ve learned by doing.

Roman: How did you get all this experience? I know that you have a degree in organizational psychology. What is it all about?

Pasha: The aspect of psychology that has been gaining popularity deals with the issues of individuals. Psychotherapy, and all things related, can be called personality psychology.

But psychologists are needed not only to help individuals, sometimes they can help solve issues for organizations. A popular request is formulating company values. 

Roman: What brought you from psychology to software development? You once said that it was out of despair. Why despair? I’ve come across many psychological startups – it seems that a lot is going on in the sphere. I mean, there’s life there.

Pasha: It’s definitely not dead. A lot of interesting things are going on. 

As for me, it is worth starting with my connection to IT. My parents were and still are mathematicians and developers. We got our first PC when I was 6 years old, back in 1992.

But I never did anything seriously with it and did not think I could. When I was 8 years old, I tried learning programming together with a girl who was my mother’s student. It didn’t work out, and my mother said that programming was probably not for me.

After university, I didn’t have that many options. I could do an internship in a consulting firm and work as a psychologist, but at that time it was very little money, and I was already married and wanted to earn a little more. 

The other option was to try something different. Between ages 6 and 22, I managed to learn a thing or two about computers, I enjoyed exploring software and got a job in technical support at a company called Poligor. I’m grateful to them, although they fired me on the last day of my probation, saying that IT was probably not for me. 

It wasn’t the first time I heard this, as you can imagine.

Roman: But that didn’t stop you.

Pasha: Right. I started working for Philips in technical support, but it was too bureaucratic for me, and to be honest, they also fired me.

Then I got a job at an insurance company where it turned out that during my time at Philips and Polygor I became a good administrator. But the company started going bankrupt, and I got downsized. This time they didn’t say that IT was not for me.

Then a classmate invited me to a scientific institute to write code for them as an intern. I told him right away that programming wasn’t my thing. He replied that I didn’t have many options, but had my head screwed on right and had to try.

So I started programming with smart forms. This development paradigm doesn’t exist anymore.

Roman: Was it the visual programming that wasn’t our strong suit at JetBrains?

Pasha: Probably, although the term is from Delphi. And you know, I did it. And then it turned out that you can still write code on top of the forms, and I did that too.

I worked for 5 years in a different team at the same place. We developed secondary monitoring systems in Java for nuclear power plants all over Russia. It was an interesting and rewarding job.

You know what was the best part? I had a chance to explore a gazillion technologies. I had an amazing team leader who allowed me to experiment. After that, job interviews were a piece of cake, because I had gained some experience with pretty much everything. I used to include a huge list of technologies in my CV. Of course, I don’t do that anymore, but back then I could.

And then things were off and rolling. I became a developer, then a team lead, then worked as a CTO for a while with 35 people under me. Next, I returned to being a team lead and then moved to a linear data engineer position.

Roman: Do you sometimes feel that you lack fundamental education in programming? If so, how do you fill the gaps?

Pasha: Honestly, working at JetBrains, it’s hard not to have this feeling. Too many people around you are very well versed in programming.

Roman: Looking closer, everyone at JetBrains, including marketers and UX-researchers, writes code. They are often very good at programming, regardless of their job title.

Pasha: Sure thing. How do I fill the gaps? The honest answer is that I don’t. I usually do research when I need to solve a particular problem. 

Going back to the talk that I’ve mentioned about full-stack craftsmen, Anton said something cool: “The more you have learned, the easier it is for you to learn new things.” Polyglots can confirm this: they say that the more languages you speak, the easier it is for you to master a new one.

But not everyone can master languages easily. For some people, it requires a huge effort. It’s worth learning all sorts of things. I learned how to make clay pots at one point. It is also fun, and it increases your brain’s plasticity too. Honestly, I don’t really think that the ability to learn declines with age. Perhaps we become slower learners, but if you keep training this muscle, so to speak, it will be easier to learn new things.

So I keep trying new technologies. At my current job, I can afford to try anything.

Roman: Are you happy with your current role?

Pasha: Totally, I do what I enjoy doing. I enjoy talking to people and I’m always on the lookout for curious things that are going on in the industry. I’m really looking forward to the return of offline events (and multiple conferences are not in-person yet) because it is so much easier to meet new people there. 

Roman: As a final thought, let’s hope that we and our readers can get back to enjoying in-person events as soon as possible.

Pasha: Right – and without having to worry so much.