Hacker News Reader

Comment by falcolas | Hacker News Reader

This is your annual reminder than vim and eMacs are fully featured and extensible IDEs that support code completion, folding, and navigation by default.

Or, no, you don’t need to use a graphical IDE to develop code, as TFA states.

Thank you for coming to my Ted talk.

EDIT: Don't believe me that VIM is an IDE? Read the threads for elucidation. :)

View on HN

> vim [...] extensible IDEs that support code completion, folding, and navigation by default.

If "by default", you mean "with the default vim configuration", then this assertion is wrong.

Vim does have a definition-search" feature, but it needs hand-made configuration for each language, and since it relies on regexp instead of parsing the language, it's useless outside of micro projects.

To enable real code completion and navigation, vim needs plugins and external tools. The modern way is to use one of the LSP implementations for vim (I've tried ALE and CoC), but that's clearly not "out of the box" for vim.

It works perfectly well with C by default - with no addons. I will agree, you do need a tags file (though it's is not even remotely hand-made (emacs uses these too)), but the rest is handled automatically, including code completion based on the contents of the tags file.

Code completion, syntax highlighting, goto definition, goto tags... these are all core functions of VIM. Addons just help it work with languages other than C.

Don't forget :make and the tooling around the error-pane for navigating to locations emitted as compiler warnings and errors.

When the completion is not context-sensitive, it's not really what "code completion" is taken to mean these days (the last decade, at least).

In the case of Free Pascal, may I remind you that there is a fully featured IDE called Lazarus which offers all of that plus an intuitive user experience (i.e. you don't have to memorize all the keystrokes before you can be productive, you can find the available commands in them menu and if you use one particular command a lot, you can memorize the keyboard shortcut) and a graphical tool to build your UI and connect it to your code.

Lazarus is already mentioned and explained in the first paragraphs of the article.

In the case of Free Pascal, may I remind you that there is a fully featured IDE called Lazarus…

That’s cool, but if you already use Neovim for other things, there’s a Free Pascal Language Server Protocol (LSP) server for it too [1]. You’ll many of the same features that Lazarus has, like code completion, diagnostics, etc. In fact, it’s the same LSP that’s available for VS Code [2] and it uses Lazarus as a backend.

Too much is being made about how hard Neovim is to configure; if you’re new to it or to Lua, just use LSP Zero [3] that takes care of all of the details of installing LSP, linters, etc.

[1]: https://github.com/neovim/nvim-lspconfig/blob/master/doc/ser...

[2]: https://github.com/genericptr/pascal-language-server

[3]: https://github.com/VonHeikemen/lsp-zero.nvim

I can see the argument for emacs being a IDE but isn't vim more of an editor?

Vi is just an editor, but vim is "Vi improved", and the improvements include the sorts of programmability that Emacs is known for, which allow modes to include syntax highlighting, code completion, and so on. It's not quite the same (the beauty of Emacs is that the executable is mostly a Lisp interpreter and the editor is written in the same Lisp you can write your extensions in), but close.

Not if you add about half a million partially conflicting add-ons to it, no it isn’t!

Sorry. Yes, (n)vi(m) is great and useful and all, but it’s not an IDE.

Vim defaults to being a C IDE, no plugins required. The features I called out above are available with no plugins.

Interesting, didn’t know, will try it. Does it do “jump to definition” out of the box?

Sure does. :) `gd`

:gd

E492: Not an editor command: gd

VIM 8.2

Do I have to activate it somehow? :)

Have the following file:

    int foo ()
    {
        return 3;
    }

    int bar()
    {
        return foo();
    }

put your cursor somewhere on the "foo" identifier in the second to last line and type "gD" (without the quotes). It should jump to the definition of foo. It's not perfect but works for much code without crazy preprocessor stuff. By default it's file-local, but you can give vim a list of include files to search as well.

Ah, upper case D, yep that works! Thanks!

yeah lower-case "d" is for local definitions (it just searches for the first appearance in the "[[" region if you are familiar with vim motions).

What aidenn0 said.

Specifically it's one of the 'g' commands (like gg which goes to the top of the file and gG goes to the bottom). Just put your cursor on an identifier and gD (goto definition is the mnenomic).

:help g

probably "gD" is what you want unless you're looking for a local definition.

So the days of using ctags are long gone?

No, you still need ctags to jump to sources outside of your current file. But within the same file, it works fine without it.

C doesn't have a defined directory structure, and a lot of the source/header files you'd use are stored in places like /usr/lib and such.

Note that cscope is significantly better than ctags and also built into vim.

Yeah, but that is the thing, an IDE works with more than one file.

I feel like you're taking my words in bad faith.

Vim works perfectly fine with multiple files out of the box, it just wants a tag file for jumping between multiple files and letting autocomplete work with those tags.

This is hardly unique to vim (and emacs) - you can't work on a project in IntelliJ without first setting up a workspace and letting IntelliJ index all those files. The only difference is how the index is generated.

Oh, and `:help cscope` (again, thanks aidenn0). In vim >=9.0 a tagging tool is now incorporated into the base vim install.

Nope, just making the point that vim has lots of things to catch up with a proper C IDE in a default install.

ctags was just the first example of many things I can refer to.

For example any basic C IDE on a default install is expected to have debugging integration, project management, among other stuff.

I'm so confused. Vim has ctags, and it works, across multiple files.

Granted I don't think vim is an IDE, but you'd demonstrate that better by pointing to the IDE stuff it doesn't do (like debugging, I think, but I debug with printf and only rarely fire up gdb so for all I know it does support it).

Op thinks it is one,

> Vim defaults to being a C IDE, no plugins required

Right, but ctags isn't the reason it's not. Ctags just works and goes substantially above and beyond what you'd expect of "Just a text editor".

It’s not an IDE but Neovim can do IDE-like things.

And you can get Neovim with all batteries included: https://github.com/rockerBOO/awesome-neovim#preconfigured-co...

bye bye emacs bye bye (n)vim

Reply on news.ycombinator.com