Turning vim into an IDE through vim plugins
safaribooksonline.com
safaribooksonline.com
Fundamentally, I think people trying to sell emacs/vim with plugins as "turn X into an IDE" are sort of not getting what people see and get from IDEs, though. There's quite a bit more integration that goes into IDEs and what you're making is a pretty barebones/poor IDE with these plugins.
Most languages, though, don't need an actual IDE for them to be great. You need the auto-completion, automatic compilation/error checking, jump to definition, easy-to-reach documentation, etc., for them to instantly be super productive while coding.
Spacemacs with Haskell plugins is one of the best coding experiences I've had and it even taught me some patterns that I didn't know about. Another highlight is OCaml tooling that works really great with both Emacs and vim.
I think even that's putting it generously. It's not turning vim into an IDE at all, just adding some modern text editor features like you'd find in Atom or Sublime.
I disagree. I've _never_ seen an integration into emacs that comes close to a _good_ integrated debugging experience. Similarly, the navigation/refactoring integrations tend to feel bolted on, rather than integrated. (you're using projectile and irony mode? They both have different representations of what your "project" is, so you have to keep both up to date). Again, actually "building" from emacs is something I've never seen done well. You've inevitably got the compile command which you have to write yourself, but my IDE can parse its own project file, generate a list of targets and configurations (predefined compiler flags for optimisation/definitions) and build those in one keystroke. I've also never seen any integration of any autocomplete that works with configurations either.
You get refactoring, jump to def, auto completion, linting, code snippets, documentation, depending on the languages you use. For Java there are more lightweight alternatives which lack refactoring features that IntelliJ has, but there has been eclim for ages. But that's using eclipse in the background you say? Well, at some point you're bound to use a language native component to use reflection.
What about Omnisharp? How was Monosharp an IDE and vim with Omnisharp integration, which was based on the same components wasn't?
I feel like the discussion has degraded to peoples perceptions of what an IDE should be. And for most people that perception is: "It should look like IntelliJ" or "It should look like Visual Studio".
Maybe what you really mean is:
It should have refactoring.
It should have auto completion.
It should do performance instrumentation.
It should allow debugger integration.
And then there's the question of how far each feature has to be integrated. For most IDEs performance instrumentation is really just a seperate tool that you can launch form the IDEs toolbar.
Which is actually awfully close in usability terms to <hotkey to next terminal> + <full featured shell> # just sayin'
Works great in the terminal and neovim.app etc.
I can understand why people who have used it for a decade prefer Vim over other text editors. They already know how to use it and how to integrate it into their workflow. For a newcomer this task, it seems, is nigh insurmountable.
Are there people who recently got into it and think it's the superior way to code and why?
For me, it was a lot of wasted time trying to learn Vim and finding out that other editors that I already use are as good or better.
From my perspective, if you're trying to turn Vim into an IDE, you're using it in the wrong way. Vim is an excellent text editor and leave it at that. Whatever you still need (build system, file management, version management, package management, debugging, log collection, and so on), build your environment with external tools that have nothing to do with Vim.
I'm using vim now for ~15 years and it all started during university on a unix machine with a limited number of options, so I was somehow forced to learn either vi or emacs. I don't know if I would have ever learned vim if I had the options of today.
But I also like powerful tools, so perhaps I still would have, and what I like most about these more powerful editors is the ability to optimize them to my prefered workflow.
Sometimes you've to fiddle a bit around, which can be very annoying, but at the end I almost always get to a solution I like to work with.
This just means you failed to get used to Vim. Has nothing to do with it being "clunky".
I use Vim for many cases, and other IDEs for when I'm forced to use them, such as Android studio (IntelliJ) for Android, XCode for iOS, and certain languages where it's hard to remember the syntax, so I think I'm qualified to answer, coming from a user of all of these editors.
For dealing with API-heavy frameworks I think IDE is good. But even then I prefer to have some sort of Vim plugin integrated into the editor so I can take advantage of shortcuts from both the IDE itself and the Vim scheme.
One benefit with Vim is that it's become almost a standard that you can find vim plugin in any IDE (Except for recent changes in XCode) so you can just expect to jump on to any editor and be immediately productive, without having to learn each editor command. You don't have that for Sublime or Atom. Sure some editors have similar commands for dealing with similar features, but not always.
It's an "editing scheme", not just a single editor.
This is why it's much more efficient in the grand scheme of things than any other editors exactly because of that, in my opinion.
Editors will come and go, but editing schemes are forever.
When learning Vim it's not wise to learn about everything at once. start slow at first, lear a few commands, then when you find you are doing something many times, try to find way to optimize it. Try not to use mouse for highlighting, use different visual modes instead (visual line, visual block are great).
Here is article be the Vim author which can give you some hints on how to edit files: http://moolenaar.net/habits.html
And as he mentions there, it can be applied to making your editing more efficient with other editors as well, so it's not a waste of time :)
I started coding with Visual Studio, and then later Eclipse. I like both IDEs. I only learned about vi/vim about a year after I started programming, and it looked intimidating.
2 years after that, I decided, fuck it, let's see if I can do this. It took me one day to learn how to comfortably navigate with the hjkl keys, as well as how to copy/paste and save/exit. Which was all I needed at first. Over the next two weeks I learned a few more things that you could do, and I never looked back.
It wasn't difficult at all to learn vim. The only thing that I can think of that would make it difficult to learn, is if you don't know how to touch type.
As for why I think it is superior:
The . (repeat) action is so insanely useful and saves you so much time.
Most actions are blazingly fast compared to a gui text editor. e.g. To delete a whole line just press dd instead of home + shift + end + delete
Memorizing all these shortcuts is easy, becuase they are based on a 'grammar' that makes new command combinaitons easy to guess.
There hasn't been one feature that and IDE has that I used, which can't be achieved in vim (or via a plugin)
vim doesn't take up crazy resources, and is installed on most systems by default anyway. And the startup time is almost instant.
Ctrl + X works on most 'gui text editors'
> There hasn't been one feature that and IDE has that I used, which can't be achieved in vim (or via a plugin)
How does "find references" work in vim? If i want to find all usages of a method called "getName", does it know how to differentiate between calls on an object of the class I'm searching from, or usages from all classes that have a "getName" method (aka dumb text search)?
So far every C/C++ IDE I've seen on Linux has been incredibly dodgy, unstable, resource-hungry, etc. The text editor compoment is invariably light years behind vim and the actual "integrated" parts are of similar quality, so I continue using vim with enough plugins to get the job done. That doesn't really give you an IDE, it gives you a coding component of a Non-integrated Development Environment, where you build and test on the commandline by running commands and scripts, commit by running git, etc. I'm honestly perfectly fine with an NDE, as long as each component does its job reasonably well. I've tried various gdb integrations and they're so horrible, I just learned how to use vanilla gdb on the console. So yes, setting a breakpoint means copying the method name from vim and pasting it in gdb's commandline, but the important part is that it works and keeps working and doesn't set the breakpoint wrong, or crash, or put my editor in some weird state, or lose connection with the debugger (literally how??), etc. So I just use ol' reliable tools to get the job done without fuss.
About the only one that I've seen that actually works is QtCreator, but its license costs more than VisualStudio's, and it's definitely not worth the price (to me or my employer). CLion I've also heard good things about, but couldn't put through its paces enough before the trial period ran out.
Visual studio and Qt Creator are the least worst IDE. The first one only works on Windows obviously. They are both free so I am not sure why you'd mention pricing issues???
Visual Studio has the best debugger by far, I'd go as far as saying it's the only debugger in existence for C++. If you have money, there is a paid refactoring plugin called Visual Assist X that makes the C++ experience a lot better.
Really? Even if you haven't selected the line? Because if you haven't selected the line then you'll have to use your mouse first or do the home + shift + end + Ctrl + X to delete the line.
I remember Ctrl + D does this (without needing to select the line) in Eclipse. But it's still faster to type dd than Ctrl + D
> How does "find references" work in vim?
Yeah
Absolutely, works for the entire line, no matter where you are.
> But it's still faster to type dd than Ctrl + D
Don't be overly pedantic. I could say Ctrl + D is faster because dd means: 'press d' + 'release d' + 'press d' while Ctrl + d means 'press Ctrl' + 'press d', or I could say that you don't have to change modes to use Ctrl + D, but you could say your finger is already on d, you're more comfortable, etc. The difference in speed is quite negligible.
> https://stackoverflow.com/a/9616315
Using cscopes sure is better than dumb text search, but apparently doesn't know the difference I asked about. From the comments:
> Now that I've spent a bit of time with cscope, it seems to me that cscope does not differentiate variables of the same name that belong to different classes. class_b::var may be returned even though I'm only looking for class_a::var. I'm using C++. Am I doing anything wrong?
Maybe it works better for other languages. However, my point is: if you think "There hasn't been one feature that and IDE has that I used, which can't be achieved in vim (or via a plugin)", then I don't think you've used JetBrains IDEs.
Ctrl + X is the shortcut for cut (as in cut then paste). It cuts the current selection. It doesn't auto select the line if there is no selection.
Ctrl + Y is delete without copy (at least in IntelliJ IDEA).
I tried ctags and a few others for autocompletion, etc. They were super complicated to install and use. Also they do not find references properly, having a bunch of misses or false positives.
I like Vi style editing, but I found it better to use a real IDE and find a Vi plug-in for it.
Find references : try [0] or [1]
go to definition (I haven't searched for this functionality, so I don't know if it exists)
[0] https://github.com/asenac/vim-opengrok [1] https://stackoverflow.com/a/9616315
It's a pretty fundamental code navigation feature. You said "There hasn't been one feature that and IDE has that I used, which can't be achieved in vim (or via a plugin)", but it seems you haven't used any significant IDE features. Have you tried refactors like "rename" (method, class, variable, field) or "extract method"? Have you tried searching for overriding methods? Have you tried inlining variables or extracting expressions to variables? Have you tried debugging? Evaluating expressions during debug is something you can do in Java and Eclipse [1] / IDEA [2].
Or, if you want something really impressive, how about Async stacktraces?[3] It shows all the frames for both the spawning thread and the spawned thread in the same stack during debug.
There are a lot of really cool features in IDEs like IntelliJ IDEA have which are impossible to achieve with plugins in VIM, simply because IDEA parses the code and works at AST level. Not only that, but there are hundreds of inspections, automatic fixes and refactors which work perfectly (or almost perfectly) on top of that AST.
[1] http://help.eclipse.org/mars/index.jsp?topic=%2Forg.eclipse....
[2] https://www.jetbrains.com/help/idea/evaluating-expressions.h...
[3] https://blog.jetbrains.com/idea/2017/10/intellij-idea-2017-3...
I was a 80WPM hunt-n-peck typist, and my typing/"business computing" teacher in High School was a 25WPM touch typist. She couldn't convince me it was worth learning, so I never did. I'd fake it and other bs until we finally moved on after about 2-3 months.
However, after programming for about 3 years, I realised that I had subconciously learned how to touch type, and with about a month of concentrating on better finger usage, I achieved a more "proper" touch typing form.
My one complaint about vim: muscle memory. After using vim for years, you'll find random :w's and :q's at the end of so many emails or documents in other programs!
Moving between machines and terminals different colorschemes seem to work better than others. This has like a million colorschemes (OK, slight exaggeration but it does have more than I've been able to review. Usually pick from 5 or 6 favorites commented out in .vimrc).
https://github.com/flazz/vim-colorschemes
Also they recommend https://github.com/Shougo/neocomplcache.vim (which I've used for years). Reviewing some vim plugins the other day I noticed that github hasn't been updated in 3 years and recommends another plugin now. (Don't plan on switching until it breaks though).
Guessing this article may be a few years old?
<edit>Yes, it says 2014 at top
As posted elsewhere, we now have vim 8, ALE instead of Syntastic, fzf/fzy instead of ctrl-p, and more.
For a more up to date approach I'd suggest Drew Neil's Modern Vim book (still in beta)[1] and using async language server plugins[2]
Wait, what's wrong with the built-in netrw? I actually started with NERDTree before I knew netrw existed. After discovering netrw, I switched to it instead. I think it looks just fine and prefer it to the more complex NERDTree.
But I've since switched to using FZF [1] and hardly use netrw anymore.
[0]: https://github.com/tpope/vim-vinegar [1]: https://github.com/junegunn/fzf/blob/master/README.md#as-vim...
Link to dbext here: https://github.com/vim-scripts/dbext.vim
https://github.com/airblade/vim-gitgutter
"A Vim plugin which shows a git diff in the gutter (sign column) and stages/undoes hunks."
* Vim mode in IDEs often only implement the most basic vim commands
* I'm able to work remotely over a slow/spotty connection
* I really hate waiting 10-30 seconds for my editor to start. Often I want to peek at code, then change my mind and want to edit it. I can remotely login and start my editor in less time than most IDEs take to load.
* I like dropping to my shell (not just a shell)
Who says what vim is meant to be? A lot of example vim setups I see are too much for me (too much to set up, too fickle to maintain, too slow in practice)...many of those apply to IDEs for me. But it's nice to see what's out there and how other people fit the pieces together.
ysiw)j.
What you said about shoehorning vim into being an IDE can be said about shoehorning IDEs into being decent editors. It's extremely hard to get both and depending on the language it's better to get the IDE with so-so editing or get the stellar editing with most of the productivity boons of nice integration.
But there are benefits of Vim that ST are ever likely to have fully:
* Open Source
* Editing inside ssh
* The programmable way of editing which you'll never teach yourself if you don't dive in. I can't even quantify if this is better, but it feels better and you only need a few percent improvement over your editing/refactoring speed to be worth it over the years
* fully custom, you set it up exactly the way you want it. I never felt tempted to create shortcuts in ST, but it's much more standard in Vim
* it's good to understand Vim's way of editing even if you go back to other editors
* in theory you can pretty much do everything that ST can do in Vim but I don't think you'll get the full power of Vim if you try to recreate it in ST
If you just want an IDE experience use one that already exists. If you want to build your own out of plugins, use something like Emacs that has something like that as a core feature.
If you really want to learn vim though, then please learn the IDE that it is already integrated in: Linux. Linux based OSes are the most extensive IDEs because in the past nobody thought there would be a difference between a programmer and a computer user. So it's the most complete system that you can find. And additionally to solving all your programmer problems you also learn an OS and its components on the way.