A lot has happened in the IDE space over the last 5 years – a quick journey through promising directions.
Eclipse Che and Theia, Monaco Editor and Language Servers
A little over six years ago in early 2016 Eclipse Che was released to the world, a radically new direction for Eclipse. Rather than the SWT-based modular Java GUI it runs in the browser which initially might seem questionable: Why would someone trade in a fast native UX with direct system access for a web GUI? It turns out the rationale behind web development goes much further than replacing GUI technologies.
Microservice architectures have seen broader acceptance and with many interacting services running in containers architectures have become more modular and polyglot. An online IDE does not merely run in the browser, it can spawn the right containers, e.g., if you develop an application with Java, Python and C++ backend components with a MERN-based frontend the IDE can spawn approriate containers for each service containing its respective language runtime as well as other containers the microservices rely on such as a NoSQL database. If you develop in one project, you will debug in one of the containers and as you click into another one, your debugger can seamlessly switch into the other environment and service. Furthermore, the heterogeneity of setups is significantly reduced. Rather than setting up linters, static and dynamic code analysis tools, code formatting guidelines etc. yourself and running into the stereotypical “But it runs on my machine” scenarios, developers get launched into a standardized environment with the click of a button. This environment can be on-premise like a local K8s cluster, but it can also be in a public cloud like AWS, Azure, Google or IBM.
Another impactful aspect evolve around standardizing language support and can be illustrated by looking at Eclipse Theia which is an extensible, TypeScript-based editor and now the default editor on Che. That’s right: Che does not rely on a single editor – you could use Jupyter notebooks, an editor like Theia or something else and it also works well with visual editor components. Theia is not just based on VSCode, but it supports VSCode extensions and two great abstractions: The Language Server Protocol (LSP) allows the IDE to support individual languages via a language server which provides things like autocompletion and rich code navigation. Thus, in order to provide rich support to many editors and development tools one can just implement one standardized language server and it also means one does not rely on a local copy of the source code to be able to navigate it. But what about debugging? These kinds of runtime interactions are the second part of the equation and handled through the Debug Adapter Protocol (DAP) which enables tools to just hide the complexity of different debuggers behind standardized Debug Adapters and thus treat them as standardized components which can be reused across environments.
Productization of Online IDEs and Notebooks
These developments have given rise to a plethora of online IDEs including Gitpod, Codeanywhere and Cloud9 (now part of AWS) among others. Since this page is targeted at AI, it is particularly relevant that Gitpod is experimenting with GPU support and there are competitors like Coder doing the same. Finally, there are lots of GPU-enabled notebook services for ML including Google Colab and AWS SageMaker Studio Lab. Eclipse Che to get back to our story is now backed by a collection of companies making it a compelling, vendor-neutral option. It originated in Codenvy which was acquired by Red Hat in 2017 which became CodeReady Workspaces and was earlier this year transformed into OpenShift Dev Spaces.
Jetbrains Gateway with new PyCharm UI
For me personally Jetbrains IDEs remain my daily driver and have their own compelling approach: Jetbrains Gateway is currently in beta stage and the new streamlined PyCharm UI is currently a preview. The image shows it running over both an X.509-secured SSH connection into an Alienware machine running RHEL 8 as well as over a password-secured SSH connection into a Lambda box running Ubuntu [I removed IPs and project names for due diligence, even though they weren’t really confidential]. The beta still needs a little polish (and you need to make sure that SFTP is enabled or it will break), but I like that it significantly streamlines the comparably complex configurations you needed before with remote interpreters and file syncs. Gateway just needs an SSH connection, downloads a remote IDE to the machine, you clone the code there and then work with a local client against that – very clean. And besides SSH it supports their own product (Space), but also Gitpod, Google Cloud, GitHub Codespaces and Amazon CodeCatalyst. The remaining question for me is how well their K8s support will work – before Gateway Docker containers worked well, but K8s surprisingly posed issues, at least for me. I have not had time to investigate the new story, but my preliminary impression is that K8s support still has room for improvement. Okteto might fill this gap as a third party provider, but I haven’t had a chance to play with their product.
Papers on upcoming IDE technologies have always been fun to read, but seen comparably slow adoption, afaict. However, foundation models might have some major impact in this space including OpenAI Codex, Github Copilot, Salesforce CodeGen, Amazon CodeWhisperer, Tabnine and the recently released ChatGPT. You might have also seen that this week’s Science features DeepMind’s AlphaCode as its cover story. I shifted my focus to foundation models early this year and need to blog more about them which as usual time constraints and the fact that a lot of my work is proprietary inhibits a bit. Still: Stay tuned for dedicated articles on why foundation models matter, are much more than just big models and will have a transformative effect on multiple areas of AI. Interestingly, for my professional life I still could not use FM-based code generation due to licensing and safety concerns, but the signs are promising that these challenges can be mitigated such that we might see Enterprise-ready offerings in the near future [general opinion, as always not speaking for my employer].