I've use Vim professionally, as well as VSCode and Jetbrains IDEs and dabbled in Emacs - the idea that one can replicate what IntelliJ does for Java for instance in any other IDE or text editor is to me, nonsensical. The amount of configuration it would require in vim/neovim/vscode to replicate the refactoring ability of IntelliJ alone would take you longer to setup than it would to code whatever project you're working on.
Saying that Vim or Emacs have "zero fiddling" compared to Jetbrains IDEs is a statement that is so vastly different to my experience (doing plenty of fiddling in both) that I would love to hear the backstory of how IDEs hurt you.
I agree with you tho, I was looking for my options to develop in Java with Emacs and decided to not even try.
I've tried Java with LSP, and I think it's on par with Eclipse rather than JetBrains these days. The language server is fine, but I've never gotten it to understand, e.g., an Android Studio project.
It is also worth noting that I have never had an issue jumping from vim to VSCode (or vice-versa) on the same project. Neither of the two need any extra metadata or configuration. They just work, and I'll choose whichever tool makes sense for whatever I'm doing at the moment. As, frankly, I think everyone should. This fixation over one specific type of tool over another is unnecessary: go with whatever you are most productive with.
Productivity is a bad word. Productivity can mean low value busy work, or it can mean high value thinking. High value thinking leads to longer term success, because it is not easily bought or replaced. It requires an individual who has invested in a breadth and depth of knowledge by not choosing the path of least resistance. We should choose tools that optimize for this type of long term success. Choosing free and open source software is a choice for long term sustainability of our industry. Choosing a tool like Vim/Emacs is a long term choice towards individual success.
This is the philosophy I follow, and I have been very successful with it both financially and in terms of making an impact on the industry. It isn't novel either, I simply emulate the many, many expert programmers who universally choose to still use Emacs/Vim despite the existence of "smarter" IDEs.
It's not even about the editor itself, nor the graphical or UX stuff. It's the crazy level of introspection and of understanding your code those IDEs bring. My daily experience is just insanely better than with anything else I've tried.
In something pretty weakly typed like PHP you can happily rename methods and classes, refactor and extract code, move around namespaces, and the IDE keeps track of everything for you. You also get very smart autocomplete, snippets, integrated debugger with REPL, the whole thing.
I've played around with all sorts of vim and emacs distributions and settings and nothing ever came close.
Maybe it's just I don't have the time to set it up propert ly. But if that's the case, it's still a point in my favor here.
Steve Jobs once said that a computer is like a bicycle for your mind. It's an amplifier of sorts and an IDE fits into that metaphor. It will amplify the good and the bad. It's up to you, as a professional, to develop the skills necessary to use the tools in ways that make sense for whatever it is you are working on.
I can agree with that. However, the real world is filled with random legacy projects, massive enterprise applications where a dozen developers came and went over a decade, quick-and-dirty MVPs and everything in between.
If you are paid to write well-crafted code that fits nicely within the limitations of your editor, that's great. But for the rest of us who have to deal with the realities of this industry, a helpful IDE makes it so much bearable.
However what I do think is important is that every project should not actively discriminate against any of the alternative tools, in every project I manage I encourage every programmer to use the editor/IDE, shell or operating system they are most conformable with (but they need of course to manage their environment themselves and deliver the code in time).
That's not true. The working memory is finite, you can't keep things in it indefinitely. You can imagine your working memory as a queue[1] - you put things into it through one end, and you take things out of the other end to put them into code. If you can't write fast enough, the queue will overflow and loose a portion of the information you fetched from long-term memory to solve a problem. If that happens, you will have to restart the solving of the problem and re-fetch the required information. This takes time, but more importantly, it disrupts your focus and has a chance of getting you out of the zone.
There's a speed of writing that, depending on the size and volatility of your short-term and working memory, is optimal for you: you don't need to work to improve the speed above that threshold. But if your writing speed is significantly below that threshold, it will slow you down and decrease your productivity. You probably naturally achieved the speed optimal for you long ago, and forgot how you felt before you got to that point.
[1] For the sake of argument only. Obviously, in reality it's more of a graph than linear queue, but it still has limited capacity.
There's a huge mental component to coding (I doubt it's 90% though). In any case, an IDE makes that easier by getting the boring physical stuff out of the way quicker.
And the speed at which you write code is quite meaningful. I can easily write 1000 lines of high-quality Rust code on a good day with just the LSP (rust-analyzer) for support. More recently, I started a project that hit some bugs in rust-analyzer -- working on it was a comparatively miserable experience.
Edit: Never mind, I see above that you're comparing a full-fledged IDE to just using an LSP. I consider LSP to be in the IDE category; I agree that LSP is just about where I want to be and that a full JetBrains-like IDE is overkill. What I don't like is not having any sort of code completion or rename support.
The rename functionality is helpful, mainly for names that are referenced throughout the codebase. For locals it's not hard to replace this functionality - narrow the buffer to the scope you want (expand-region helps), then use iedit or multiple-cursors to perform the change. For public names referenced in multiple places you can use grep-find, then wgrep with iedit or multiple-cursors to do the rename. It's more work, and you risk renaming things you didn't intend to rename (ie. it's not semantic), but it works also with languages that have no IDEs or LSP implementation, so it's worth knowing.
There is nothing wrong with this. We shouldn't let old text editors hold back the productivity of programmers.
VSCode is pretty cool and is easy to use right out of the box. It does some things with ease that would be very hard with Emacs. And JetBrains looks like it does some amazing stuff.
I still end up sticking with Emacs myself, but the idea that that it’s perfect and simple and for everyone and that there’s no sensible reasons to use the other options is just insane.
Its only "user" is the business that made it; they have full access to the source (unless they deleted it; whoops!), are not bound by its copyright (since they're the owners), etc. The FSF has no problem with that.
Although my first job was working on FOSS, all the ones since have been working on such bespoke, in-house software. To be honest, I don't think I've ever seen a job ad for proprietary software (as in, closed-source software that runs on end-user machines).
A few subtleties:
- Javascript is probably a glaring exception. Opinions differ on whether it should count as shipping proprietary software (the FSF think it is, many HNers probably consider it less clear-cut). For what it's worth, the little JS I've written professionally has always been of a progressive, site-still-works-without-it form.
- Some of that never-released software may be accessible to others, e.g. Google's search software can be accessed via google.com. The AGPL has an interesting take on that particular niche.
- Sometimes the human end-users of this software have very limited access/control over it, e.g. if Walmart maintains its own checkout software, those operating the checkouts probably can't access the source, etc. However, that's nothing to do with copyright, FOSS, etc. it's just a business decision, presumably covered by employment contracts (e.g. "in the course of your work you may be given access to computer systems; these are confidential, and you must not hack/compromise/etc.").
But you yourself bought up convenience in your original comment. If your argument is a purely moral one then no need to specify how little fiddling is required to get LSP working. But I do think if your only argument is yelling at people about it being immoral to use VSCode you ain't going to get far. Why not talk about the cool things Emacs has while acknowledging the things it still has that could be improved?
VSCode is open source by the way, MIT not GPL but you can go compile it yourself (or use VSCodium).
The extensions marketplace requires you to use the closed source version. Quite a few of VS Code's best extensions are also completely closed source. VS Code is already on the same path that Google took with "Open Source" Android.
The idea that either emacs or vim are a "0 fiddling" drop in replacement for Goland or Pycharm is ludicrous. I probably could get vim up to the point where I was as productive as I am with Goland/PyCharm but it would definitely NOT be a "0 fiddling" process.
I can't believe debugging and learning a new code base would be ANYWHERE as easy with vim as with Goland/PyCharm.
Also, both Goland and PyCharm have pretty good vim plugins so my day to day editing IS vim. Sometimes I hit stuff that I can do faster in actual vim and I switch over.
Modal editing is not really something that is needed anymore, and a lot of people don't have time to learn a new language just to move about in their IDE - just click the mouse button ...
> Modal editing is not really something that is needed anymore
Honestly, I'm not sure it was ever "needed", but that's not really the point IMO.
It's hard for me to think about editing text in any way other than how Vim handles it. Part of that is admittedly just familiarity, but I think there's also something to the idea of treating strings as more than just arrays of characters. Once you start thinking about your text and code as nouns of various sizes and granularity [0], losing those feels cumbersome.
In order to achieve the latter, you either need modality or a huge number of control hotkeys. Vim takes the former approach while Emacs (and IDEs) takes the latter.
So yes, you can achieve the "crowning feature" of Vim (IMO) without modality, but I don't see modality itself as being a pro or a con as much as a design choice. If you don't prefer it, more power to you.
> and a lot of people don't have time to learn a new language just to move about in their IDE - just click the mouse button ...
This also works the other way. I don't want to have to learn where all the buttons are in $IDE just to move my text about. Thankfully, many IDEs include a Vim mode or plugin for it, but those are never quite the same.
Every tool has some level of learning curve. If you want it to be more flexible, powerful, and to get the most out of it, that learning curve is gonna be steeper. That goes for both IDEs with their buttons and Vim with its modal commands.
For something that you might use for hours on end every single day for professional work, putting in some time to learn it pays dividends. For both Vim and IDEs.
[0]: In vim parlance, this is effectively what "movements" operate on. They sort of define these objects via implication.
Every tool has strengths and weaknesses. Plus, some of us enjoy learning new tools and find it fun to switch things up occasionally.
Otherwise, the website linked above is a good way to get started, there's also an integrated tutorial in Emacs (C-h t).
I use Emacs for lots of things, but I've long since changed to Pycharm for Python programming. That's been close to 0 fiddling for real. Its been pretty good for JS programming too.
(Well, good luck writing one in Xcode, for that matter.)
(not supporting the editor/ide war troll, just trying to contribute some useful info here)
JetBrains Intellij Idea Community Edition is open source
You mean the repository at [0] contains code which is not licensed under an open source license? The only license mentioned at the root is Apache 2.
As for telemetry, all my work lives in Azure so I assume Microsoft are already collecting what they want about our codebase (which is publicly visible) already.
Edit: Just yesterday HN was overtly critical of Warp for being a proprietary, closed source, telemetry laden terminal, but they’ll suddenly lose their morals when it comes to text editing over perceived conveniences of an IDE vs. a “text editor” with LSP.
The point of Vim/Emacs isn’t just that they are good editors. It is also you voting with your installs and money for free and open source tools. You already reap the benefits of the Linux ecosystem, the least you can do is help out by picking a FOSS editor.