IntelliJ Remote Pair Programming: A How-To Guide

IntelliJ Remote Pair Programming: A How-To Guide

On the day we stop lying to ourselves, it'll dawn on us that most "collaboration" tools hogging the spotlight today just weren't made for us developers. At least not for remote pair programming in particular. Yes, people can see and talk to each other, bringing back the "we're working together" feeling they enjoyed before the pandemic (but that feeling has yet to come for coding teams).

In the same way, GitHub works better for code versioning than it does for other teams' needs (despite claims otherwise). Remote pair programming with any of the mainstream tools (Zoom, etc.) leaves a lot to be desired.

This post takes a developer through the how-to of IntelliJ remote pair programming. We'll also look at several ways you can bring back the high productivity associated with coding in the same room as more teams go remote. To achieve this, let's look at what collaboration means. Particularly when using IntelliJ as your preferred IDE.

What Does IntelliJ Remote Pair Programming Mean, and Why Is It Helpful?

It's important to note up front that IntelliJ has been dominating the JVM developer market, with a 62% market share. It only makes sense then that developers should be able to collaborate on projects without leaving the IDE. Upon achieving this, you can safely claim you're practicing IntelliJ remote pair programming.

The points of contact when collaborating within IntelliJ are as follows:

  • Code sharing
  • Task tracking and reviews
  • Continuous integration (CI) as a team

We'll go through each of these touch points when we reveal the tools to make them happen a little later in this post. However, it is their existence that makes it easy for developers to gravitate toward IntelliJ.  When activated, the boundaries created by distance when remote working crumble to the ground.

Remote pair programming is a simple way of getting work done in teams while solving any technical debt concerns beforehand. Effectively, collaboration on IntelliJ means shorter paths to commits and reviews and fewer tools used while still including the core processes of an agile workflow. This upholds information visibility and makes life easier for project managers and their teams. (You'll see how in a moment.)

What Are the Collaboration Features Built Into IntelliJ?

Straight from the box, IntelliJ comes with built-in features that enable collaboration.

The most notable of these tools is version control. This feature brings in the all-important code-sharing touchpoint we mentioned earlier. By default, you're able to clone repositories from one of three code versioning systems: Git, Mercurial, and Subversion.

Select repository from the list of code versioning systems

With this feature, you can branch from a project's main track and add your effort. It especially helps freelance developers working with different clients with any combination of version control system (VCS) preferences.

How Do You Enable the Built-In Collaboration Features?

Create repository in version control system

Before distributed version control systems, developers had to have local access to the folder on which the code lived in order to take part in collaboration. This meant the screenshot above would ask for a path to the local folder. Activating version control in IntelliJ is done by simply selecting which platform you use for control and cloning your desired project.

Version control is still possible when the project started on your machine. The VCS menu item has an option that allows you to import into version control. Here, import works as would export in word processing applications, only that the VCS option you select becomes the main file location both locally and in the cloud.

It's almost as though the version control system (and all its behaviors) is a part of the IntelliJ IDE straight from the box.

Collaborating this way, while useful, is far from all that's possible with IntelliJ IDEA. However, you may have to install some IDE extensions in order to enjoy IntelliJ remote pair programming at its best.

IntelliJ Remote Pair Programming Features Provided by Integrations/Extensions

Integrating your instance of the IDE with plugins from JetBrains Marketplace brings in a horde of features and functionality capable of carrying out some amazing feats.

You could practically make a cup of coffee straight from your IDE's toolbar!

However, because we're focusing on collaboration, here are some IntelliJ remote pair programming features you can harvest from the marketplace.

  1. Code With Me: share the same page with a partner and watch as they type in code as it appears on your screen
  2. Upsource: share code with user tags, review commits, and keep a close eye on the health of a project's files, all in the IDE
  3. YouTrack: agile project management and collaboration in a way that developers comprehend
  4. TeamCity: maintaining high-quality code as a team and a central CI manager

How Do You Enable the IntelliJ Collaboration Features Provided by the Integrations/Extensions?

Activating the IntelliJ remote pair programming features that come with each of these integrations requires that you download said plugins first. Both you and the other member of your pair should have them installed.

While a dashboard-like plugin for all these tools, Hub, is free for an unlimited number of users, the other plugins have a per-node pricing model. Piling up the features results in a directly proportional increase in license fees. Also, your developers would have to use the same IDE—something a lot of developers will not be too happy about. It's something of a pay-to-win scenario.

Going back to the question of total cancelation of all collaboration itches a tool needs to scratch, these extensions are the equivalent of a golden wire brush. It can get expensive even if your development team is only a handful (five to ten) of people. All the while being restrictive because you'll all need licenses for, well, everything from JetBrains.

We're not saying doing it this way is terrible. But what if you could share screens, have a text chat and voice chat, and have a multi-cursor and input session with developers in real time? This is like bringing everyone in front of the same screen for a proper pair programming session. We're just saying you could do one (or more things) better.

Enter ... drum roll, please ... CoScreen!

How CoScreen Enables Users of Any IDE to Collaborate - also of IntelliJ

With CoScreen, you're not restricted to a particular IDE in order to collaborate with teammates. This is possible since the application doesn't attach itself to the dev tools themselves, but the overall environment instead—allowing pair programming the way other tools can only but envy. Teams can huddle up and watch code take shape regardless of where they're working from.

IntelliJ Remote Pair Programming + CoScreen

While it doesn't cancel out the need for version control systems when developing world-class applications, using IntelliJ and CoScreen together approaches code quality maintenance and code review from a unique perspective. Code is discussed and patched in groups, with the senior devs directly giving feedback to the team. From this alone, your team incrementally increases in skill faster than they would by only reading notifications from commit boards. Clearly, coupling CoScreen and IntelliJ remote pair programming features will result in more enjoyable collaboration for developers.

To sum things up, here's what you can do with CoScreen:

  • Activate a common screen with your development team such that all windows (IDEs and all) in the viewport are visible and editable by team members.
  • Video and voice chat through the shared screen.
  • Use multiple mouse pointers and have the ability to enter code to the same file from each user.

These three core features complement the collaboration and pair programming tools of any IDE. With CoScreen, your developers can maintain peak performance in the OSs and IDEs of their choice while opening a portal to an even higher performance collaboration and peer programming opportunity.

This post was written by Taurai Mutimutema. Taurai is a systems analyst with a knack for writing, which was probably sparked by the need to document technical processes during code and implementation sessions. He enjoys learning new technology and talks about tech even more than he writes.

Show Comments