Hacker News Reader

Comment by estsauver | Hacker News Reader

I always find the benefits of portability to be a rather funny one: It's always immediately followed by 800 lines of dotfiles that do an incredible amount of customization.

The IDE vs. vim/emacs purist debate is always crazy to me. There are some places where IDE's are almost certainly better: Java in a large project in IntelliJ has to be 100x better than in Vim. For new languages or languages where there isn't substantial IDE integration, it's probably 5x better in Vim/Emacs with a nice configuration.

View on HN

Just wait for the vim guy who will be like "but muh java plugins make it more efficient then IntelliJ"...

I think i am more productive in an IDE, faster. Sure if you have this insane VI/EMACS setup that you have tuned for years. Good for you, you probably are a fucking wiz.

My standard right now is a terminal & IDE combo. Working in the cloud era as a data person, you need to be comfortable with terminal & vi/emacs (vi for me but whatevs) as it makes life a ton easier. I hate watching co-workers do terminal shit and write code. Seriously guys if you invest a little time into VI pretty soon you are flying around your code. People literally watch my screen and are like WTF are you doing. I feel like a surgeon with precise incisions, cuts, tweaks. Compare this to spamming down arrow 30 times and then right arrow 80 times to get to a character in your editor...

> Sure if you have this insane VI/EMACS setup that you have tuned for years. Good for you, you probably are a fucking wiz.

To share a glimpse of the mindset of us on the editors side: that insane Emacs setup I've been tuning for years enables me to be "a fucking wiz" not just with Lisp. The very same setup lets me work efficiently with Python, Shell, configs, SQL databases, HTML+CSS+JS, running a personal Wiki, organizing tasks, tracking time spent on those tasks, billing customers for that time, reading/writing mail, and a bunch of other things. We love our editors because of compound interest - we get to reapply the same tricks to almost every task done on a computer (and we complain loudly when we can't shoehorn a task into editor-oriented workflow :)).

That said, I'll still grant you're better off with IntelliJ IDEA for Java. For the time being, at least. I'm having high hopes for language servers trend - they're the bridge that could enable vim and Emacs to reach feature parity in all the places they're currently deficient compared to IDEs.

> The very same setup lets me work efficiently with Python, Shell, configs, SQL databases, HTML+CSS+JS, running a personal Wiki, organizing tasks, tracking time spent on those tasks, billing customers for that time, reading/writing mail, and a bunch of other things. We love our editors because of compound interest.

I think that's really the takeaway here. Spending time in your environment allows you to accumulate skills that let you solve pretty much any text based problem you can think of.

Whether that's using emacs with elisp or vim with shell scripts and Unix tools isn't important. It's having that playground of an environment to solve arbitrary problems.

> Compare this to spamming down arrow 30 times and then right arrow 80 times to get to a character in your editor

Or uses the mouse to get there. I don’t get that part of vim. Weirdly I do like Vim. The thing is you see something in sublime, you just click on it and you there. You don’t have to solve some vim puzzles to get the cursor on the right spot.

GP isn't talking (just) about jumping between files or function definition. The difference between Vim and regular IDEs is this: in Vim, you notice an arbitrary piece of code on your screen, tap tap, you're there, tap tap, you've transposed it with another piece of code somewhere else in the file, tap tap, you're in another file, tap tap, you're back in the previous file, except it now contains half of the code from that other file, tap tap, now with proper namespacing. All done at the speed of thought - an experienced Vim/Emacs user thinks in semantic steps, not shortcuts. In regular keyboard+mouse approach, you either do operations that perfectly align with automated refactoring capabilities, or just have to click a lot.

> I think i am more productive in an IDE, faster.

Personally agree with this part.

For those who need it because they are used to vim style editing most ides (at least on the Java side, + VS Code for everything else) has vim modes.

For those who have never used it and think they need it because it seems so cool and "everybody" uses it: You don't need it, at least not right now. Most great developers I know actually don't use vim for programming high-level languages, even if some of them use vim modes.

Instead I'd recommend:

- Use a decent mainstream IDE

- Memorize shortcuts for selection, search, replace, global search, global search and replace.

- Learn to use the included refactoring tools

- Learn to use the built in VCS tooling (or try and fall back to the console for VCS handling).

> Just wait for the vim guy who will be like "but muh java plugins make it more efficient then IntelliJ"...

I think you described the base of most arguments in that direction right there. The problem to either side isn't so much what the other side's doing (who cares, really? To each their own…).

Usually, those discussions are fueled by people asserting how obviously the respective other side is inferior without having even had a proper look at it. My bias tells me there's much more of those on the IDE side, but I expect that's due to the way people are introduced to programming (if one "population" tends to be much bigger than the other, I suppose there's a higher chance of someone belonging to it starting a flamewar. And, of course, if it's also prone to have more newbies in it, the probability of… unaware statements also rises).

Only a sith speaks in absolutes.

I have known several vim purists who are extremely productive in Java/Scala/Kotlin.

I both understand and respect your preference for Intellij. But, your dismissiveness of others is misguided.

Sure, there are definitely some folks who are excellent in those languages with Vim. But when you think about the amount of time that's required to make Vim comply, the amount of mental state that's required to manage the things that could have been taken care of by an IDE, I can't help but challenge the idea that there's nothing possibly better than tools.

By analogy, I don't believe that a chainsaw is either a bad tool or that it's impossible to make good art with a chainsaw, but I do believe most marble sculptures would be better suited to a chisel.

When comparing vim and intellij,

vim is a lot closer to the chisel, while intellij is closer to the chainsaw.

I think you're missing the point I'm making, they're different tools that serve different purposes:

IntelliJ is really great at managing large, statically typed, Java/Scala/Enterprisey frameworks. I have never seen a vim setup that effectively generates and manages javabeans. I have never seen a vim setup that manages an xml spring configuration file correctly (or even understands how to resolve xml namespaces and validate them.)

But vim is very lightweight, it's incredibly customizable, it's adaptable. It is faster for editing text. If you're writing a new language that doesn't have integration with IntelliJ's language protocol, it's probably better. If you need to jump into the source code of other libraries to understand what's going on, Vim tends not to be good at that sort of thing.

Regardless of which you think is the chisel and which is the chainsaw, there are some software engineers trying to cut down trees and some trying to make marble statues. The "all software engineers who don't use my tools are fools!" mentality doesn't make sense.

No, I believe I understood the point you're trying to make, but I disagree with it.

I've worked directly with several VIM devs on Enterprisey frameworks who were not held back by their lack of Intellij.

"Only a sith speaks in absolutes"

Do you recognize the irony in that statement?

OP must have been quoting the King James version, a more accurate translation would be:

"In general it's usually a Sith that speaks in absolutes."

I’ve recently started opening the large java project at work in emacs because I didn’t want to deal with how many resources IntelliJ uses when I start it up with a huge Java project.

Sure, but if you're a professional developer, the cost of buying extra RAM to compensate for that is recaptured within hours or days.

There is some deeper, irrational motivation in people who make this argument.

I have 64GB in my laptop... which might be taking it too far.

Or you could connect to IntelliJ from emacs.

https://github.com/Ruin0x11/intellij-lsp-server

(Though unfinished, it's at least proof the concept could work.)

Personally I use omnisharp at work for C# projects, on Windows, and am able to accomplish all the tasks I need to do except debugging entirely in emacs, and get refactoring, diagnostics and completion.

Also https://github.com/emacs-lsp/lsp-java

My approach is to just setup Emacs once and edit files remotely from my one setup of Emacs. I mostly use Emacs for remote editing, otherwise I use IDE's if resources are limited I go for VIM / Sublime Text. Whatever helps me to work quickly given a situation.

> I always find the benefits of portability to be a rather funny one: It's always immediately followed by 800 lines of dotfiles that do an incredible amount of customization.

I'm not seeing a contradiction, given that config files are trivial to move around. Yes, I have a possibly excessive number of dotfiles, but they work fine on everything from Arch Linux to Termux on Android to OpenBSD and are just a clone away.

I tend to switch back and forth depending on what I'm doing. I haven't found a Java IDE that can match vim+fzf for speed of editing, and ctrl-n autocomplete is generally good enough. For debugging, refactoring or working with some API where better autocomplete saves looking at the docs constantly I'll switch to IntelliJ.

I launch emacs from intelli for text editing.

Or take the best of both worlds with VIM IntelliJ plugin :D.

I normally find that IDE Vim plugins are almost good enough, but not quite. They fall into a kind of uncanny valley where they'll support most of what you need, but that makes the bits that are missing more jarring.

That, plus they often break other functionality. Using a Vim plugin with Eclipse made using the refactoring functionality a lot more fiddly, IIRC.

You are using Java as a convincing argument for using an IDE... Java... ugh..

If you use mainly statically typed languages where IDE static analysis, refactor tools proves super useful to you... keep using that set up.

I don't really see the appeal personally.

I don't think the argument itself is Java. I think the argument is that heavy, corporate projects (typically written in Java or C#) can have lots of benefit from IDEs. This isn't to say that there aren't terminal utils that aren't powerful enough to handle such a project. But being able to Ctrl + Alt + LMB an interface and being taken to the implementation (or shown a list of all implementing classes) or pulling a graph of your DIs is damn delicious. It's those types of creature comforts that makes using an IDE worth it for me.

> "I don't think the argument itself is Java. I think the argument is that heavy, corporate projects (typically written in Java or C#) can have lots of benefit from IDEs."

I think this for me is the gist of the problem... A lot of corporations prefer these large monolithic codebases, with a thousand different interfaces and abstract classes.

I think this is a mistake in design, and prefer simple applications with simple interfaces. They are easy to maintain, and are more reliable as their are less moving pieces.

I'd rather write a small app/service in python, c, JavaScript than work in some horrifically gargantuan and abstract Java code base.

This is a problem with enterprise in general, they'd rather incur technical debt to stuff in new features into legacy monoliths, instead of designing small applications and services with simple interfaces.

Managing large businesses is complex, and requires complex software. Spreading the complexity between various codebases does not make the software less complex. Large codebases in COBOL, Java and C# are what make the world go round.

You seem to be under the impression that Java code bases are inherently "horrifically gargantuan and abstract". I would just like to say that is not the case - they are often like that, but they do not have to be. In my time, I have worked on many Java code bases that are small and simple, and not abstracted-to-hell.

It's not inherently a problem, but I do think that there are certain measures that can be taken to reduce code bloat, stack size, and development time. Someone else already noted that large business software can be a bit complicated solely based on the business needs. Regulatory rules and the ability to audit certain actions in the financial industry tend to add a bit of complexity to business logic, and those are completely unavoidable by law. However, some of this stuff is good practice that comes with boilerplate.

A classic example is defining your services in interfaces with a separate class for the actual implementation. This means that even for services that will only be implemented once, you now have the class and an interface. But with an IDE (and since the mappings are clearly defined, I'm sure this wouldn't be a monumental task without a GUI), you write the interface, create a class to implement the interface, and the IDE generates your methods. That's minimal overhead for an IDE, but it require a bit of work on your part to manage in something like vim or emacs.

This has nothing to do with their core point. Yes, Java sucks. This doesn't prove that IDEs suck too. They make Java bearable. They can make editing simpler languages better as well.

I think you misread or I didn't convey my point well enough. I'm not against IDEs. I think they definitely have their place and are a great tool for development.

I run a complex business. I can guarantee you that I would really prefer if it was a simple business with simple interfaces, dependencies and rules :)

It really depends on how much resources your company has, what you're trying to do/prove/show, and how long you have to do it. Google gets idolized for their software, but the reason they can have so much perfection in their software is the amount of money their core business throws off, not the other way around.

Reply on news.ycombinator.com