Hacker News Reader

Comment by tootie | Hacker News Reader

I'm admittedly an IntelliJ fanboy but I also make extensive use of VS Code and I think JetBrains are 100% correct. The kind of extra features you get from a really good IDE are so easily worth it if you spend even a small amount of time learning how. You may need to invest an hour or two getting it to understand your project setup but then you have real-time debugging, refactoring, granular test running (and debugging) right away. I think the move away from IDEs is coupled to the move away from strict typing (which I also hate) because IDEs lose value when they can't reliably understand your code.

View on HN

Yes, but on the other hand, IDEs are slow. I don't mean to say VSCode is lightning fast, but it starts in less than a second. By that time, IntelliJ didn't even open it's loading window. And were talking about a top-of-the-line Ryzen 7 laptop with an NVMe SDD.

For longer sessions that's not a problem, but when you're on battery or quickly hopping into the project to look something up it makes a lot of difference. Also, opening up a foreign project is two clicks and one second, compared to project creation and then loading+indexing when using IntelliJ.

I love the IntelliJ line of IDEs. But VSCode outcompetes it in simplicity by far. Especially when we're talking about something like a simple Node project, where compilation+execution is far simpler than something with a full build pipeline with artefacts.

But the trade off here is indexing. Visual Studio code provides no indexing functionality by default (some LSPs provide basic caching but not much). This is the killer feature for me. I can load up Kubernetes in Goland, cook an egg on my laptop while it indexes (about a minute) and have lightning fast goto def and find reference for the rest of the day. VS Code will load quickly but every single goto def will take ages.

> VS Code will load quickly but every single goto def will take ages.

I wouldn't blame that on VS Code but on the relevant extension. Go to Definition is instantaneous for me when I'm working in TypeScript

That's why I mentioned longer sessions. I tend to jump quickly between many new projects, in which case the indexing is annoying.

When you start a longer session, the overhead is very much worth it, I agree fully.

I prefer to have the application ran on my machine in a fashion similar to how I'm going to deploy it. Using a "large" ecosystem IDE detracts from that as the application is now ran by an application rather than in a system. And almost all the features you listed are possible in VSCode. You just have to take an hour or two to set your system up to run it.

> And almost all the features you listed are possible in VSCode

As someone who wishes they could drop everything else and just use Kate or VS Code, I disagree. IDEs like those that JetBrains offers have refactoring tools that are unmatched by what VS Code and its plugin ecosystem currently provide.

Depending on the language you're writing VS code plugins are a bit hit and miss. I've tried using it for Rust dev for example, and everything kind of worked, but with way too much jank. I constantly had problems with autocomplete suggestions being duplicated and linting being slow or not updating errors. Enough to make me wish I had a dedicated IDE.

More widely used langs have better experiences though I'm pretty sure. And maybe Rust support has gotten better? Seems that other commenters in this thread had positive experiences.

There has been rapid improvement in rust-analyzer for a while, so yeah, stuff has been getting way better for quite a long time. Every week there's new stuff with it.

I think there's room for both. And if I've learned anything watching node developers working in VS Code it's that they work exclusively in webpack dev mode and let npm worry about production.

I get real-time debugging, refactoring, and granular test running/debugging in VS Code. I also work almost exclusively in TypeScript, F#, and Rust. My anecdata says that this argument isn't very accurate.

How is there a move away from strict typing? If anything it's the opposite in dynamic languages - Python/typing, Ruby/Sorbet, JS/Typescript, PHP/type hints.

Vscode is used by by many Rust and Go developers. I would wager to say it’s the most popular IDE for those languages.

For those who don't know, JetBrains has a plugin for Rust (I think really targeted at CLion but i think its installable from multiple IDEs like Pycharm as well)

https://www.jetbrains.com/rust/

and of course, there is the GoLand IDE

https://www.jetbrains.com/go/

Which I personally like alot.

VSCode doesn't interpolate HTML variables for me. Its the small features that add up over time I miss whenever I try to switch development environments.

VSCode has a really good TypeScript/JavaScript and admittedly Python developer story, and the ecosystem has produced some pretty robust Style editing extensions, but if you want things like autocompletion for your template variables, I've always found you have to look elsewhere, whether it be handlebars, django templates, Jinja templates etc (and this is one example, among many)

VSCode doesn't autoload JSON schema (need an extension or hope for the best)

VSCode Extensions are also suffering from some pretty serious lack of maintenance too. Lots of extensions, very little movement on updates. I've had more than one of them break on me in major ways.

I've recently developed a Rust app using CLion + Rust plugin, and I love that interactive debugging works, and works well. It's kind of awesome.

I wonder how much of that is just the lack of really good IDE tooling for Rust? GoLand is pretty good, so I don’t know if similar question applies to Go.

Java pretty much requires an IDE because it's verbose, bloated, everything is inconvenient without IDE assistance and it's easy to create bugs.

Something as simple as opening a file of code requires IDE, because everything is hidden behind `./src/main/java/com/whatever` nonsense. The language was designed for IDE.

In Rust there is hardly any need for IDE (or a debugger), as long as your text editor has LSP support. Hell, even without LSP support it feels quite OK to write Rust code.

I use Intellij for Java, and Kakoune for Rust, and I really dislike working with Java. The fancy refactoring features don't make up for how verbose, clunky and inexpressive Java is.

The Rust way is to have great modular and reusable tooling for everything. Even stuff like complex refactoring can be achieved without an IDE with something like https://github.com/google/rerast

Because the only viable alternatives are vim and emacs, which require a bunch of upfront config outside of the old-school pure keyboard interface.

Yes but they are clearly missing something and that's simplicity. I use goland because ei get go refractor and move utilities but I get annoyed when I feel like I have to fight it to do simple things. I think the default keyboard shortcuts between the two products show a lot.

Reply on news.ycombinator.com