Can a Cloud IDE Replace My Native IDE for Java Development?

As I thought about bringing my laptop for a short day trip, one of the reasons was to access my Integrated Development Environment (IDE) if I needed to look at some Java code because of a high-priority issue popping up or if a colleague had a question that would require a quick dive into the code to troubleshoot.

Granted, I can use the web view to look at the Git repo where our code lives but we all know it's not the same as looking at the code through the IDE and all the benefits it provides to jump around to different classes.

Considering that so much of what we do is web-based nowadays, I started thinking about if cloud IDEs have improved to the point where I could actually use one as my primary IDE.

I remember how when Google Docs first came out, it wasn't really a replacement for Microsoft Word and I would still always install Microsoft Office on any new computer. However after all the refinements to it over the years, now I use Google Docs and its associated suite of apps in Google Drive (Google Sheets, Google Slides, etc) and haven't installed Microsoft Office in 10+ years.

So if I could do the same with a cloud IDE for my Java development? That would be a no brainer to use going forward and something I set out to see what's currently possible.

Firebase Studio

For this test I used Firebase Studio as I had previously set up an account back when it was known as Project IDX and from some Googling, still saw it as one of better cloud IDEs in terms of its features, functionality and being built on top of the popular Visual Studio Code (VSC).

And depending on your perspective on the different AI LLMs, it comes with Google Gemini as the AI coding assistant.

Setup

After going to https://firebase.studio/ and signing up with your Google account, you can then use Gemini to ask it to create an app for you as a starting point:

In my case, since I wanted to import a workspace with projects I already had stored in a Git repo, I chose the Import Repo option instead.

After cloning the repo into your Firebase Studio workspace, since for our Java projects we use Maven to build and package our Java applications and want to debug them in the IDE, I then installed the Maven for Java and Debugger for Java extensions by going to Extensions on the left side menu and then finding the Maven for Java and Debugger for Java extensions and selecting Install for both:

Doing this then added a Maven section to the Explorer menu so I could have a quick way to see all my Maven projects and easily run Maven commands on them:

Since the Firebase Studio workspace comes with a terminal window to directly interact with the VM that's running your IDE (I didn't see any option to select the OS and noticed that it was Red Hat by default), if you want to be able to do any program commands from the terminal window, you will want to include their packages into the workspace.

The workspace includes the dev.nix file in the .idx folder at the top level of the workspace which contains your workspace configurations. Since I wanted to be able to run java and maven commands along with sudo on my VM, I added the following packages to dev.nix in the packages configuration:

    pkgs.jdk
    pkgs.maven
    pkgs.sudo

After adding them, I then had to choose the Rebuild Environment option for these to take effect in my workspace.

Because of the way our Java apps are built, including some of the open source libraries we use, I needed to add certain VM arguments for when I debug/run the Java apps in my project:

-Ddeveloper-quickstart=true --add-opens java.base/java.nio=ALL-UNNAMED

It wasn't as straightforward where to add these VM arguments as I had to dig around a little bit to find out where to store them.

You can configure these arguments by going to Settings (the gear icon in the bottom left of the browser window) > Extensions

And then finding the Debugger for Java extension we previously installed and choosing its Settings (the gear icon in the bottom right and then selecting the Settings option).

Once in the Debugger for Java extension's settings, we then go to the Java > Debug > Settings: Vm Args section where we add any VM arguments we need when debugging/running our Java apps in the IDE.

The one thing I noticed is I had do the Remote settings which apply to the entire workspace versus my User settings for it to work:

As well, since we host a repository where we deploy our packages (along with where we store packages for specific versions of open source libaries we want to explictly use) and this repo requires authentication, I had to find a way to have the Maven on this IDE reference my edited settings.xml with the repo authentication settings.

For the case of the Maven for Java extension, which adds the ability to run Maven commands from the Explorer menu as mentioned above, we have to store the settings.xml on the VM and point the Maven for Java extension to it.

By default the workspace path is /home/user/<workspace_name> so in my case I just created a maven folder in the workspace and put the settings.xml there so the file path would be /home/user/saiborne/maven/settings.xml.

Then goinb back to the workspace's Settings (again the gear icon in the lower left of the browser window) > Extensions and finding the Maven for Java and choosing its Settings (the gear icon in the bottom right and then selecting the Settings option), we then modify the Maven: Settings File property to point to the above file path which requires use to actually modify the settings.json directly:

In settings.json, we change the maven.settingsFile property to point to /home/user/saiborne/maven/settings.xml.

Like the Debugger for Java settings, we had to modify the Remote settings for it to work. And this only applies to running Maven from the Explorer window i.e. choosing commands from the UI:

If you run Maven from the terminal window (see the Build section below), you will need to update the Maven command there to use this path or create the default ~/.m2/settings.xml (/home/user/.m2/settings.xml) that Maven uses by default as its configuration file.

With this all set up, I was able to then start building and running my Java projects.

Building

Right-clicking a project in the Explorer Window under the Maven section and choosing the Run Maven Commands option will allow you to run all the major Maven Build Lifecycle commands. If you need to run custom commands (for example if you want to skip tests with the -DskipTests option), you can choose the Custom... option which will open up the dialog to enter custom commands:

The extensions and the IDE itself continue to be improved as when I first tested this out there wasn't an option to run custom commands other than running it through the terminal window.

At that time, I had to run the Maven command manually in the terminal window, doing a cd to change to the directory in the workspace where the pom.xml was and running the command:

mvn clean install -DskipTests

Debugging

To debug or run a Java application from one of your projects in your workspace, you can just right-click the Java main class in the Explorer window and choose Run Java or Debug Java. Just like VSC or other IDEs, when in debug mode you'll be able to add breakpoints and then stop and resume, see variables and their values at the breakpoints, etc. Once you've got it all set up, it works pretty well like any native IDE.

Takeaways

My biggest takeaways after getting Firebase Studio set up as my cloud IDE:

• With the platform being new, the documentation is sparse and you can't find as much help online or using Gemini so a lot of trial and error and figuring it out yourself which is why I wanted to document my journey here. Long-standing native IDEs like Eclipse, IntelliJ or VSC have large communities where others have run into the same issues so its easy to see what others did to resolve their issues. Sometimes it's a limitation with Firebase Studio (like the ability to run custom Maven commands) but as you can see, they continue to improve the platform to add new features.

• As of the time of this writing, the storage for the VM is part of Firebase's Hosting plan so you get 10GB free and then can sign up for their Blaze (Pay as you go) plan that's $0.026/GB above the 10GB. So if you have a lot of projects that you build/package locally whether its for testing or before you push them to a repository (like we do, which is another story) and they take up a lot of space locally, then this space can run out quick in Firebase Studio.

• If you run other applications locally as part of debugging your Java projects, besides installing them on the workspace VM through the terminal (same as installing it on your local computer), you then have to consider the disk space for these applications. For instance, I run MySQL since my Java projects integrate with it so there's the disk space needed for this. Of course, I could run a cloud database (such as AWS RDS) but there's the cost of running the cloud database including network I/O on both Firebase Studio and the cloud database.

• Firebase Studio is still a preview so there are some minor issues and nuisances. For example, unlike a browser tab with Google Doc that you can have opened but not active (i.e. you have other tabs you're using actively) and then you return it hours or days later and it just works right away, the Firebase Studio tab goes "idle" where when you make it active again, you get a message about having to restart the browser window for it reload everything. You don't lose any data but I assume that Firebase Studio is putting the VM to idle after a certain time of nonusage which is why they tell you to restart.

  
  

Overall it does work well once you get through all the setup and figure it out for your use case. And being in the cloud, you just really have to do the setup once. The biggest hurdle will be the aforementioned costs which can really add up being on a monthly/subscription basis versus the one-time cost of buying a laptop for several years. So functionality-wise, it seems to do what I'm looking for, it's just whether the costs are really worth it at this time versus carrying out around a "development" laptop that has the heavy-duty specs needed to run an IDE.