This post is an introduction into a series of tests with different IDE´s and editors one can use for development with AspNet core (and dotnet core in general of course).

I want to use this post to explain the criteria  I used for testing and how I structure the tests. Because those products are quite diverse I do not expect to get an extremely clear result, because lots of the uses of those editors/IDE´s is in the end boils down to personal preference.

But I want to explore new ways to work with code and want you to have some new insights about those products, that maybe can enhance your productivity or coding experience.

Which ones will it be

First of all I have two IDE´s in mind that make sense to me : JetBrains Rider and Visual Studio for Mac, Yeah did I mention that I am developing dotnet core on OS X? 😉 (Visual Studio on Windows is more advanced, but because I want to work on Mac I see this as the only viable option 😉 ).

The third one we are going to examine will be VS Code, which is a light weight editor, but has a lot of extensions and supports Web development very well.

So what is the approach to this

For the test I will define different criteria that can be used to test for productivity and ease of use. I will then test each of the three products for this criteria and write a single post for every aspect (as is the plan).

At the end of each post I will assign points to each editor. Three for the best in this category, two for the second and one point for the least convincing in that category. As mentioned I do not expect some super objective results but I´d guess it gives a pretty good overview. Also this is more for entertainment and insight than a scientific result…

At last I am going to write a post about which of the IDE´s has the most points, and which I would recommend in different contexts, and which style they might fit best. Maybe each product can be used to much avail in different scenarios, we will see.

In the end I know that this is mostly personal preference with regards how people work and what makes them more productive. But simply by looking at different criteria, I think all of us can learn some twerks and perks about this three IDE´s/ editors and increase our productivity.

As those three products are not supposed to be used exactly the same, I will look at them in a way that I think they can be utilized in the most useful way. That is for VS Code I will utilize a lot of extensions when it makes sense, as well as I will use plugins for Rider and Visual studio for mac.

What Criteria do I know yet?

Hands down, I cannot predict if I find new criteria on the way in this series, but for now the following are planned to end up in a single post or in different posts (hopefully in rapid succession 😉 ).
I will now shortly look into the criteria we will apply to those three products.

Creating a project will be the first criteria. We look at how fast it can be done from templates (if any), how they are setup and how much customization this allows. The most important evaluation here is what one has to know upfront to create a template. So ease of use is more important than flexibility.

Typing experience is going to follow this. We are going to look at how it works out with intellisense, code completion in general and syntax highlighting and so on.
The most important aspects for this are performance and accuracy.

Unit testing  in general and TDD in particular are the best practices I think every developer should get used to. As I am quite the advocate of this a fast execution and good integration of test suite and testing frameworks is important to me. This will be tested with xUnit, nUnit and MSTest (the classics of .net so to speak).

Refactoring is another point for code quality and productivity expectations. We will look at renaming of variables, classes and namespaces. (the most tricky in my experience), extraction of methods and interfaces and so on and so forth.

Terminal integration and the command line are the next criteria we will take a closer look at. I love to work with the CLI, especially with the dotnet, git and database tools. Therefore I obviously need to test how the terminal integration does work for all of the products. Important points here are how well the commands integrate with the editor/environment.

Extensions and Plugins are a huge part of all three, as I mentioned above. So naturally we will also look at how easy you can extend for things like Linting, docker support, git flow and other git extensions, snippets and so on. Here is obviously not only the amount but also the quality of extensions the important factor.

Debugging experience must not be forgotten else no single IDE or Editor would be complete without it. Here we will look at the stack trace, local variables evaluation, multi threaded debugging and more.

As I probably will find some bugs and inconveniences on the way I will then create another post with all of the things I encountered during this testing phase and how much they impaired my work experience.

Last but not least I will explore how those products behave when they are used with things like concurrent testing, huge solutions/project structures and things like that. So this is all about performance in everyday scenarios.

And as I said in the beginning of this post, I am going to create a summarizing post were I will present my conclusion(s).

Some side notes on this test

Please be aware that I am a human being, and this is not the end all be all of code editor evaluation there is. I am highly biased because of the workflows I am used to have, but still try to be open minded.

In the end I just want to gain new insights and experiences at my everyday work. What I want to express is this: Do not take all this too serious in this series, see that you can take something with you and learn about those products. But in the end you need to decide for yourself which you want to utilize in what situation.

The test phase will start in August 2018 and probably be finished at around end of September 2018.  I hope it will be as much fun to read as it will be for me to test all of those products in different environmonts 🙂

Summary

This introductory post sets the theme for my series on development tools for dotnet core to boost your productivity (and mine in the best case scenario 😉

I demonstrated some criteria we are going to look at during this series and how they are evaluated.

Have fun as I probably will have.

Leave a Reply