Anyone here go IntelliJ -> VSCode?

For those who went IntelliJ -> VSCode and stuck with VSCode, what made it stick for you?

Every now and then, I get tempted to switch from IntelliJ to VSCode, but it never quite sticks for me -- I end up going back to IntelliJ. For those that do stick with VSCode, what made it stick for you?

I switch from IJ to Code just to have something to drive rust-analyzer, but today I'd be undecided between Code and IJ.

Benefits of Code:

  • faster startup and better support for CLI workflows. I do $ code . like a thousand times a day. If you work on a single project that doesn't matter, but I checkout random github repos all the time
  • more minimal UI: my VS Code looks pretty close to Emacs aesthetically
  • magit: edamagit - Visual Studio Marketplace
  • settings are a human-readable json file
  • a lot of people swear by VS Code remote dev capabilities, though I didn't compare those with IJ

Benefits of IJ:

  • polish: "go to class" doesn't have artificial delay, "file structure" is a tree menu, tree controls are in general more intuitive, gutter icons are like infinitely better than code lenses, cursor positioning during edits is much better.
  • features: IJ does support more powerful forms of refactors
  • business model: IJ is a traditional "pay money, get software" tool, user is not the product.

Cost. I'm mostly quite positive about paying for software, but after a huge income drop, the All Products Pack was more than I could afford. The IntelliJ Community Edition does much but not all, and I prefer where possible to use one editor for everything. I moved to VSCode exclusively for a couple of years and found it IntelliJ's equal in most areas. I think the path was smoothed for me by the fact that I use vi keybindings everywhere they're available. I suspect if I were still doing any Java I might have found it harder to switch.

Personally I think that if a language is so complex and it's libraries so tortuous to use that you need an all singing all dancing IDE to deal with it all something has gone wrong with the language and libraries. I'm old school, brought up on BASIC and assembler.

However, here we are. VS Code and rust-analyser work a treat. What more do I need?

Often I just use vim with nothing more than a syntax highlighter installed.

1 Like

Well Intellij's refactorings and other code intelligence features really do make dealing with large Java codebases a pleasure. And although the Java ecosystem often does match your negative description (Spring aaargh ... ), that's not primarily what makes IntelliJ work well in that context. It's the strong typing, and IntelliJ's understanding of it. LSP's refactorings are quite primitive by comparison.

I guess I have never really understood what "refactoring" means. I just think of it as a glorified cut'n'paste or global replace. What am I missing?

In my career, typically a project assembles a team, we spend a year or two designing and writing code, it gets deployed and runs for the next 10 or 20 years. Everyone is happy. No really. The guys in the team move on to other things. I guess "refactoring" was never a major problem to think about.

It understands the java AST, so a 'rename' (the simplest example) is of a method or class or other semantic entity, not a string. You can extract a method, or pull a method up (to a superclass) without manually editing multiple sites.

That just isn't how much (actually I'm pretty sure most) code is written. You might think it 'should' be, but if (for example) you're running a small consultancy and you insist on a year up front to design a system, and refuse the daily sales-driven changes demanded of you, you'll be out of business in a week.


You are very lucky if you can finish writing code and your employer is happy. This means that you have clear definition of what your code have to do. That's extreme rarity today.

Most of the code is written for people and people are finicky. They couldn't explain what they want and what they would like and/or dislike.

That, in turn, means that no code can ever be finished. Simply because requirements change all the time. Even if you would manage, somehow, to write code which solves a given task perfectly… it would still return tomorrow with request to change something.

Refactoring is, indeed, not that important if you have stable criteria which your project have to satisfy. But I'm really surprised such things things exist today. Couldn't even imagine what kinda of devices you write code for that they don't change all the time.

Even TI Calculators which looked as if they stuck in XX century today are changing! TI-83 went from 8bit, single-CPU device to 24bit + 32bit dual CPU device. I would expect there was significant amount of refactoring in that gradual move.

1 Like

Refactoring isn't just about dealing with changing requirements, although it sure helps with code maintenance over time. When I use an IDE, I rely on refactorings everywhere, regardless of the type of project and the language. Even if I write a one-off script, or edit a config file, I will use refactorings if available. They are a way to reliably automate simple common transformations.

Sure, you can do all that by hand, but that's slower and more error-prone. The friction would be high enough that most larger scale transformations would never be done, even if nothing technically prevents them. I don't need to get all my variable of function names right the first time, I don't need to care too much about factoring functions or data types, or which style to write code in (e.g. for loop vs iterator chains, or the amount of intermediate variables). I can write the first draft in a quick and dirty way, thinking about the domain problems and not surface code organization, and once I'm done, I can easily beat the code up into shape using refactorings. Some expression looks too complex? Extract more variables. Some naming is off? Change it, as often as you like. Thinking that a function is too long or does too much stuff? Extract parts of it into separate functions.

You can grep for a name if you want to change it or find all usages, but you would have to sift through entirely irrelevant results (e.g. fields, functions and local variables with the same name), and you can make mistakes if you misunderstand the context and get the types wrong. It's a lot of work, and on a huge codebase it's often unreasonably hard to do manually. An IDE, on the other hand, already has all your code indexed and all types inferred. You can ask it, and get exactly the relevant results, and nothing else.

A high-quality IDE frees you from dealing with irrelevant minutes of coding, and allows to focus on the important tasks: domain logic, public API, architecture, algorithms.


Thanks everyone for responses.

If I have read everything correctly, the main pros of VSCode are:

  • faster startup
  • remote dev
  • free

But as far as I can tell, no one is making the argument that VSCode beats IntelliJ at editing code on local machine (and most seem to suggest IntelliJ is still better at refactoring / goto-class, etc ...).

My understanding (which is based on the vibes rather than first-hand experience, since I don't use VsCode) is that rust-analyzer performs more precise semantic analysis than Intellij. For example, Intellij Rust still doesn't have an implementation of borrow checker (there is a corresponding inspections, but it checks only variable intialization, poorly).

Outside of Rust, the semantics are usually not so complicated, so the better UX and refactorings of Intellij win.

Now a days I am my own employer, so I'm happy :slight_smile: [1]

So I understand.

Presumably there are limits to this infinite flexibility in the face of ever changing requirements, otherwise one would not even know what direction to start out in and ones code would have to accommodate every possible unknown twist and turn in the future. I am by nature or experience leaning toward the more directed, rigid end of the spectrum. Otherwise I could never get anything done. We don't have any clients who are willing to pay forever for their endlessly changing requirements. Might be sweet if we did :slight_smile:

Back in the day I worked on such things as the Boeing 777 Primary Flight Computers, Rolls-Royce jet engine management, military phased array radar and secure communications systems, process control systems... These things are rigorously specified, largely dependent on the hardware they live in, subject to stringent safety standards. They are not going to be changing very quickly if ever (save bug fixes). Any change becomes a whole new, lengthy, project in itself. I guess we are still making stuff like that somewhere [2]

I wonder about those calculators. I imagine software for the early ones was written in assembler. Also that the later ones are using a high-level language, say C. That is not a refactoring that is a total rewrite. I have been involved in such migrations from 8 bit to 16/32 bit projects. Assembler to HLL. It's interesting to figure out what the assembler does and recreate it, given there is no documentation an almost no comments in the code!

  1. Actually, I'm pretty much never happy with my own code. Always something I'd like to improve on if there were time. At least with Rust I can be a lot more confident the thing is robust and correct if I can make the compiler happy. The compiler is my boss!

  2. Seems Boeing became more "agile" in their approach. Judging by the troubles they have been having in recent years.

1 Like

What you describe does indeed sound useful.

I guess my problem is having tried to use low quality IDEs in the past:

Visual Studio - Seems to get in the way all the time. Had it's own build/project system that was no use for the embedded code I was writing. Was not cross-platform (is it now?)

Eclipse - Bloated, slow and confusing. Always a pain to get it to actually work in the first place (Maybe that is better now a days).

Quartus - Bloated, slow and confusing (it's based on Eclipse).

Various other IDE's from micro-controller vendors. Always seemed to end up with some kind of lock in to their product.

Is IntelliJ that long lost "high quality" IDE I have been missing? Have the others improved since I last looked?

With VS Code and others, it looks like the dividing line between editor and IDE has become very blurred.

Whilst I have always been nervous of refactoring due to the huge possibility of introducing errors I'm much more relaxed when dicing and splicing Rust code. The compiler pretty much won't let me mess things up. Do I still need that all singing all dancing refactoring tool for Rust?

That's an argument for refactoring tools, not against. Strong type system means that automated transformations are much more reliable and powerful. There are still bugs, and macros always throw a curveball, but in generally refactorings are reliable. I would still manually verify the changes, but it's faster and easier to do than applying the transformartions manually.


Why do you think “enterprise programming”, all these factory factory factory systems were invented?

It's also why so many people who try to learn Rust rush to create “soup of pointers” designs. They are teached to not even think about design because it would be wrong, anyway, thus you can just start, cobble something together and iterate while customer is willing to pay.

Not as sweet as you think. Simply because when changes are driven by desires, not needs “pay forever” becomes “pay till nearest serious crisis”. Thus you have steady, often abundant, income when economy is booming yet tend to lose when depressions starts (like… right now).

Maybe, but I'm no longer sure. If the process would have followed 737 MAX fiasco would have never happened. It was precisely do what others (like Apple in Macbooks or Samsung in phones) are doing: paper of the hardware deficiency with software patch.

I don't think so. Why do you think they went with weird 24bit CPU of 2001 year design for 2015 year refresh? It's because you can use more memory (new model have 256KB when old one had 24KB) yet still retain these old assembler programs. There were intermediate models with old 8bit CPU, but color screen and 128KB RAM, but 15Hz CPU turned out to be too underpowered for “large” 320x240 color screen. And before that they successfully added USB-OTG to that old design. And yes, it's pretty complete, one, you can use it with USB stick if you use third-party programs.

No, no, no! Rewrite also happened, actually it happened twice, once with TI-92 which used 68k 16/32bit CPU and later TI-Nspire with 32bit ARM. Both proved to be much less popular than refactored versions of that XX century design. Of course constant refectorings meant not just new features, but also new bugs thus they switched from mask rom to flash rom in the end of XX century, but they absolutely continued to use that old ASM-based thingie because they had no choice! Even TI-Basic have substantially different dialects on these three different branches and the original ones are by far the most popular.

They added 2nd, 32 bit CPU, because, apparently no one wanted to write Python interpreter on assembler for two decades old dead-end architecture. And it was literally added to that calculator by attaching small box to it.

They faced the exact same dilemma TI did. Customer have come to them and said:

  1. We know there are these new things available (color screen and python for calculators, new, more frugal engines for the Boeing)
  2. We have tons of manual, training centers, trained teachers and trained professionals. You have too, 100%, ensure all that would stay valid after upgrade.

Not do you achieve that without refactorings?


No, but Visual Studio Code is cross-platform and you can even used with Rust.

Visual Studio Code is happy to pick compilers from Visual Studio.

I don't see where you have looked on something not C or C++ based. Refactorings in C and C++ would always be flaky and dangerous because C type system is just so inherently weak and C++ doesn't have strong typing in their metalanguage, it's duck-typing all the way from the bottom to the top.

You can not build reliable tools on that foundation. CLion is decent, but it definitely is weaker than most Java or C# based tools. And I'm sure Rust-based tools would soon be better than CLion's offers.

You never need them in any language. But in language like Rust there's hope that refactoring tools would actually work (except when you are using proc_macros because these can do so many crazy things).

rust-analyser. I actually dislike-to-hate quite a few aspects of VSCode compared to Intellij/CLion, but... I don't know what state the Rust plugin is right now, but a year and a half ago when i switched it was underwhelming at best.

Things like not highlighting issues check/clippy would, or erroring out on the perfectly valid code for some reason (or, for almost a year, sometimes failing to see certain modules in dependencies,so they won't show up in suggestions and any code using them was automatically marked invalid, even though it compiled and worked fine), so before switching i basically had to have a terminal window with cargo check running in parallel with the IDE just so i could see the sane output, which kind of defeated the point of using an IDE to begin with...

P.S. Plus, remoting over SSH inside an IDE, so i can compile, check and run my project on my server, while editing code on my underpowered thin laptop but still getting all the benefits of a language server is rather neat.

This topic was automatically closed 90 days after the last reply. We invite you to open a new topic if you have further questions or comments.