We discussed the inevitably of bugs in an earlier blog post. Product teams need to balance between innovation and feature requests all within a deadline-driven business context. But with the pressure to move faster also comes the tendency to take shortcuts, increasing the cost of future maintenance and customer support for the resulting lower quality of software. So how do we ensure developers have sufficient time and resources to maintain codebases?

Well, collaboration and teamwork make the dream work. 

Research supports that proper design reviews identify nearly two-thirds of defects and code reviews identity more than half of software defects

Hence the reason for stand-ups, pair programming, and reviewing code. While these practices are valuable to individuals, teams, and organizations, they can take away focus on producing daily deliverables.

This blog post explores the use case of cloud-based integrated development environments(IDEs) for improving development workflows around reviewing code. 

Enter cloud IDEs

Software development usually takes place on individual machines using desktop applications like the Eclipse IDE, VSCode, and respective IDEs from JetBrains. With the adoption and popularity of cloud and container technologies, much can be said about software development tools running in the cloud. IDEs are no exception to this shift. 

Cloud IDEs are integrated development environments based in the cloud. IDEs let you write run and debug your code. Typically developers set up IDEs on their local machine, but Cloud-based IDEs allow you to develop software with just a browser. Since the IDE also runs in a cloud environment, the benefits include:

  • Not having to maintain and set up projects locally,
  • better sharing and collaboration (through shared development environments),
  • Direct integration/access to cloud services
  • improved context switches (when working with different projects, branches, etc.), and
  • centralized control and confidentiality of source code.

If you’d like to learn more about cloud-based IDEs, I recommend looking at Cloud9, which is now a part of AWS. Cloud9 was the first cloud-based IDE. Eclipse Che is an open-source solution and serves as a Kubernetes-native IDE. The look and feel of many browser-based IDEs like Eclipse Che may be familiar to many developers, as it is built on top of Eclipse Theia. Eclipse Theia an open-source project that produces an extendable platform for developing browser and desktop IDEs. 

2016 introduced the Language Server Protocol (LSP) and the Debug Adapter Protocol (DAP). Since then, it’s been great to see many IDEs converging to support language runtimes equally. With projects like Eclipse Theia, we can start to expect better developer experiences and tools for working on cloud-native applications. 

Making a case for cloud IDEs

The biggest takeaway around cloud-based IDEs is the improvement of development flows. Typical code review workflows involve some configuration to change branches, rebuild, etc. to run the version of the code in review locally. This is because online code review tools don’t often provide the ability to run changes or edit and add code. Hence the rise of many web-based IDEs that only require a browser to run. 

Code reviews need the proper setup and attention to be meaningful. So, developers need the tools necessary to manage context switching away from their work. Typical workflows require some configuration to change branches, rebuild, etc., and online code review tools don’t often provide the ability to run the code in review or edit and add code. Projects like Gitpod aims to remedy this and give a natural extension to shorter-lived interactions with source code management tools (in this case, GitHub).

Image Source

The case should be made however, that there are also trade-offs to relying on cloud-based IDEs at this time. Referencing the Eclipse Foundation’s project page, we can see where it notes these consequences:

“For the time being there are still many good reasons to prefer a locally running desktop editor, some of which are:

  • bad network connections,
  • deeper integration with local operating system features, and
  • the use of multiple different tools for different tasks (e.g., Git clients, editors, shells)” [link]

A sound recommendation is to consider slowly integrating solutions that make sense for your technology stack and developers.

Better developer experience means improved development 

Organizations are realizing an improved development experience leads to better software quality. Cloud IDEs have an interesting role to play in the space of improving the developer experience. This blog post discusses the use case of cloud IDEs for better code reviews in the longer term to hopefully maintain code quality and keep costs down.

Coincidentally, I believe this is the reason for the investment of features like GitHub Actions, which allow developers to automate their development workflows. While I mentioned Gitpod as a solution for GitHub based in-depth code reviews, I still believe Cloud IDEs have drawbacks and are still at it’s earlier stages of maturity. So there is a case to be made around continuous delivery and building workflows that enable the best outcomes for developers. 

I shared a post earlier this month about how to use GitHub Actions with Harness to do continuous delivery. I hope this provides more insights into software development. 

Keep Reading

  • What is CI/CD? Everything You Need To Know

    What is CI/CD? Everything You Need To Know

    This blog post will share everything you need to know about CI/CD, from code changes to continuous integration, continuous delivery, deployments, and CI/CD pipelines.
  • Modernizing Jenkins CI/CD Pipelines

    Modernizing Jenkins CI/CD Pipelines

    As paradigms start to shift and with the rise of Continuous Delivery, leveraging Jenkins for a complete CI/CD pipeline can be seen as a “DevOps Duct Tape”. In a recent webinar with DevOps.com, a very knowledgeable pair of architects weigh in on where Jenkins fits in their respective ecosystems today.
  • Intro to Deployment Strategies: Blue-Green, Canary, and More

    Intro to Deployment Strategies: Blue-Green, Canary, and More

    Deployment Strategies For Continuous Delivery. Which Deployment Strategy Should You Use: Basic, Multi-Service, Rolling, Blue/Green, Canary, A/B Testing?