From Eclipse to VS Code: First impressions


I have been developing using the Eclipse IDE basically since college. In those days, being able to use a complex IDE was seen as the mark of the professional developer. Freshmen coded using a simple editor and the compiler directly from the console, geeks used an editor like Vim and some build tool to automate the build process, but to code “like a professional”, you used the mighty IDE.

In one of my latest classes, there was a even a teaching assistant that insisted that we use an IDE for one of the big projects in the last year of Computer Science. We were required to learn to use it well, this is, learning the shortcuts and going beyond just using it as very heavyweight editor. This was very useful later for my professional career, indeed, using the tools of the trade and going beyond just “programming” meant that you were ready to enter the workforce.

I learned Eclipse, and kept it for good. The main reason is that my professional career mostly took me to Java and later to develop tooling for developers and engineers using the Eclipse Platform. Using Eclipse was the natural choice for this. Now my career as a tooling consultant is taking me to the web and to the latest and greatest VS Code and the likes, like Theia IDE, which offers me the possibility of jumping to the web tools and IDEs bandwagon without completely abandoning my beloved Eclipse Foundation.

In this article, I’m sharing my first impressions after starting to use VS Code for some personal projects. The feeling is weird, but the experience of getting out of the comfort zone is refreshing. Just a small disclaimer before starting. I’m writing this article from the point of view of someone very new to VS Code, maybe I’m wrong about some of the features, maybe they exist but not in the way I’m used to, or in the place I would expect them. So, let us start:

The project

My first shock when opening VS Code for the first time to do some coding was not finding a way to “Import a project”. In Eclipse, the notion of project is central. The first thing you need to do is import a project and then the project becomes the central point of interaction with all of the code. The project needs to be imported because it is the way that the IDE makes the code its own.

The project is central because it tells the IDE to interpret some folders as code, and compile them, some others as resources and put them in the classpath (for Java at least), some other files as tests, and allow to run them as unit tests. So, once the Eclipse has recognized a project it can handle, the full power of the IDE is available for that project.

VS Code on the other hand starts from a simple folder, no import into the workspace, just a folder with sub-folders. It all starts it seems, when you open a file. All folders seem to be equals for VS Code, no special folders for resources, code or tests, just folders and sub-folders. Do not get me wrong, VS Code understands the different kinds of folders, it just does not make an effort to put make that structure visible for the developer.

For me, this was a bit strange, but I see how this can be beneficial for the person who comes from a simple editor. Just files to edit, and the rest of the functionality just appears as you need it.

The extensions

VS Code is very intentional about not being an full IDE and clearly positions itself as more powerful than an editor and less powerful that a full blown IDE. Eclipse, since I use it, has the possibility of downloading prepackaged versions for different uses, do you need to develop DSLs? get the Eclipse for DSL developers, Java EE? get the Eclipse for Java EE developers, C++? the same.

So, in my Eclipse-wired mind, the IDE is modular, but it comes with a bit more than the basics to start. I’ve never used an extension for simple things in Eclipse. When I used an Eclipse plugin it was to support something like a new programming language or big framework. If the framework is big enough I could even get a version of Eclipse that includes everything necessary.

My first impression of VS Code is that the number of extensions is overwhelming and some extensions do really small things. There are extensions for things like keymaps, to make the shortcuts like the Eclipse shortcuts, to change the color of the brackets, to enhance the native git support (GitLens). This is confusing for me because I would like to just download VS Code and have all the important and necessary stuff. In particular, the stuff in GitLens should be included in the base installation, at least for me.

So, I feel that to use VS Code as a true power user, I’ll need to explore a lot, to try new extensions regularly or read the latest extensions in the programming languages I use. Maybe I’m wrong here and after a month I’ll have everything I need and will never check the extensions marketplace again.

All in all, extensions, and the usage that it is made of them in VS Code is something new for me. Let us see how my taste for extensions evolves with the time.

The Web Orientation

I have used Eclipse for web development in both Java,Scala and Scala.js, and I must say that I have never felt very at home with the web parts. I usually end up using other editors to handle the JavaScript, CSS, XML and HTML files, since it never quite felt natural in Eclipse.

The tutorials I have done, all present examples using JavaScript, CSS, XML, etc, and I must admit that Web development feels at home in VS Code, it clearly was made with Web development in mind and it shows, indeed, the meta description in Google for the VS Code website says: “Visual Studio Code is a code editor redefined and optimized for building and debugging modern web and cloud applications”. Eclipse, on the other hand, feels at home in Java and JVM based languages, which is normal, since it was created for that end.

Maybe one of the things that bothered at the beginning was exactly that. My first tests with VS Code were with Scala and Java, both JVM based languages, not exactly what VS Code was optimized to handle.


These are my very first impressions with VS Code. This will surely evolve and I plan to revisit this post in the future with the insights I gain after earning some more experience with this IDE.

comments powered by Disqus