Hacker News Reader

There are languages and environments that are more prone to requiring IDEs.

For example, when I write React and I use the Foo component, either it is defined on the same file or it is in one of the imports.

On the other hand, with Angular, the foo component is not imported anywhere. In fact, there is no foo component, just one or many Foo components which declare to use the foo tag, and one or another may be loaded depending on the context of the current component. Good luck getting anything done with such an obfuscated environment without tools to deobfuscate it.

And then you have the heavy enterprise frameworks that make a science out of obfuscated code, so that you don't know what code is being executed, because it is hidden behind several layers of inheritance and interfaces, and the instance to create is choosen via xml-configurable meta-programming based dependency injector. Working with such code is guaranteed insanity without heavy IDEs. I would say it's also insanity with heavy IDEs, but people tend to find that opinion controversial.

> Good luck getting anything done with such an obfuscated environment without tools to deobfuscate it.

There's always the option of not working with such obfuscated environments. I know I don't.

> - Error highlighting.

this so much. it's priceless to just type a line and have some warnings such as "hey, you're moving this value but using the variable afterwards, take care" or "hey, it looks like you are only using this argument as a reference, consider not passing it by value" just pop up next to the offending line ; when compared to an IDE-less workflow I pretty much divide the amount of hitting "build" I need by ten or more since the IDE tells me everything wrong beforehand.

I get those exact same warnings in Vim :)

Vanilla vim without any extension ? Otherwise you're just reimplementing your own IDE by hand in your vim config

It's 8 lines of config, more than half of which are cosmetic customizations for colorblindness accessibility that I'd need with an IDE anyway.

Obviously extensions.

And it's not "reimplementing" the whole IDE, it's choosing and configuring parts to work just the way you want it to, and it's usually done in a handful of lines.

a handful of lines + the additional processes that do the parsing behind the scene. Just because it's split across multiple processes doesn't not make it an IDE.

Any sufficiently advanced vim config would contain ad-hoc, poorly specified, bug-ridden implementation of a half of Intellij IDEA :)

If those are the things you're using to define an ide, then vim/emacs/vscode have been ides for a while now.

Seriously, lsps have gotten really good.

... Including refactoring?

By refactor do you mean rename across the project, or extracting a chunk of code out into a function/method?

Rename across the project is introduced by lsps.

As for renaming, I don't use it particularly often, but it's documented in microsoft's code action documentation[0] to include: Extract method, Extract function, Extract variable, Extract interface from class (some of those might be language/server dependent).

The neovim framework[1] at least does provide a wrapper for the code action.

VSCode gets most of its capabilities outside text editing from language servers. So the rule of thumb is that if VSCode has it, vim/neovim/emacs usually have it these days.

[0] https://microsoft.github.io/language-server-protocol/specifi...

[1]https://neovim.io/doc/user/lsp.html

Just about every editor has a language server support nowadays, that's far from a compelling argument to use an IDE. Even emacs/vim have those now.

For Java at least, the language server built into IntelliJ is comically further ahead than VS Code + extensions.

I know I'll make some people not happy by saying this but the only reason you need so much complex IDE tooling with Java compared to other languages is because the language itself & the tools associated to it are not very well designed. Just about everything requires some insane boilerplate where it should not.

It's not a solution to a problem, it's a problem searching for a solution.

I don't entirely disagree. But the situation is what it is.

The reality is that Java at this point is a mature platform broadly supported by many, many stakeholders. Its benefits and issues are, in general, decently well known and understood.

Billions (likely even trillions) of lines of Java are running in production today and those applications will need to be maintained moving forward. IDEs make Java development a much more pleasant experience and so there will be a place for IDEs.

Yes I do understand why things evolved that way, it does make sense, all the tooling is there to improve the environment. I just personally don't want to work with such tech as much as I can though.

I'd like to point out that you don't need an IDE for error reporting. Most editors these days integrate with a language server for inline errors and linting. Even features such as jump-to have existed in Vim/emacs for many years.

I would add graphical debuggers to your list. You can get by with command line debuggers and there are external attachable debuggers but neither is really comparable to an IDE.

Depends on a language.

Perl for example is extremely difficult for an editor to get right, especially if you use OO framework other than Moose.

On the other hand, as others pointed out, where is the line between an IDE and a sufficiently customized editor using language server?

... and you are right about graphical debuggers.

I left them out because I very rarely use them, unfortunately. It's my personal vice, of sort. I tried to learn to use and love them, more than once, but never learned to be more efficient with them than without, and when a deadline hits, usually drop them and never look back.

I grew up as a programmer without graphical debuggers, developed a rather sophisticated way to debug with essentially "print" statements, but on steroids -- I have a library of debugging utilities which I kind of recreate for any language I am working with. I've a habit to anticipate where they may be needed, and my code is usually peppered with commented out debugging statements (of course all of them generated via code snippets), which help me to be very efficient in debugging my code.

I must say that some of my collaborators over the years hated it, others loved it, adapted my system and used it in their own code.

I think it would be good to un-learn this habit and learn to use debuggers efficiently, and to produce a bit more conventional code. On the other hand, life is short, and there are only so many fights you can hope to win...

It's easier than you think! I picked up command line debugging in a couple days when working with software that was extremely difficult to printf debug.

Does emacs or vim with lsp count as an IDE?

I would say yes, although they might not be as featureful as special purpose IDEs.