Hacker News Reader

Comment by hguhghuff | Hacker News Reader

I’d use an ide from day 1 instead of wasting time with vim.

I seriously dramatically slowed down my advancement as a programmer because I didn’t use a full featured ide straight up.

Now I only use vi to edit files in /etc

View on HN

I'd use Vim from day 1, instead of wasting time with several IDEs.

Spaces! No tabs.

The real advice is try different tools rather than sticking with the first one you try or were told to use. When you find the one for you you'll know. Also remember you can make your own tools. Don't struggle with crap tools and find a way to make it easy to develop your tool kit.

It's been a long time I haven't used Vim. I left it in favor of Evil+Emacs a few years ago. And I don't recommend it to every single person I see.

The phrase "wasting time with Vim" was the thing that made me reply the way I did. Learning Vim properly has helped me every single step of my way.

So you don’t use vim as a programming environment/editor?

So not actually disagreeing with me, just stirring?

"Vim"? No. I don't use it anymore. The "Vim's Way"? I use it everyday!

Evil is a Vim implementation in Elisp, basically.

And I'd learn to use the tools that were most appropriate to the environment I was working in and not spend so much time 'optimizing' my own workflow for relatively small gains in productivity.

Except 11 out of 10 such tools come as a command line tool that has to be integrated to your IDE, often by someone else.

Why would anyone not want the power of an ide?

Is it a Unix tough guy thing where there’s nothing that a GUI app does that you can’t do better in a terminal? Or is it that you’ve never really spent a lot of time in a professional ide so when you argue against it, it’s cause you don’t know?

I've used several IDEs before. I used one when Eclipse was the go-to option. Then all the attention went to IntelliJ. But none of them gave me what my Emacs+Evil setup gave me, while the Emacs side got "almost" everything they gave me.

Probably this. IDE developers listen to users and they do build in those features that make vim better than Notepad. Same with grep and anything else command line excellent. I think it is best not to think one or the other but use both. iDEs work on Linux and have a terminal window built in. So that is how to do it, vim keyboard bindings too.

Vim keyboard bindings offer nowhere near the capabilities of a real Vim. They only offer the basics and never advanced vim features. Vim is so much more then just keybindings, it is more of a text manipulation language. There is only one exception to that and that is Emacs Evil mode.

The other way around is much more likely: Vim plugins offer all those IDE features and integrate them seamless into vim and its way of manipulating text.

Honestly, after learning and modifying vim for myself I found IDEs to be limited, bloated and slow.

I thought the same until recently and found the underlying java nonsense of an IDE to be slow, forever indexing. But due to work I had to use an IDE. Much to my surprise it was not slow. Plus I learn from it. I like the code errors showing and I like learning new things from the auto complete. I also like the plugins for database and Redis stores. Plus debugging is great. Give it a go and avoid modding down those that wish to share their experiences!

I used plenty of IDEs (from free ones up to expensive enterprise IDEs) and I still prefer Vim. In fact I started with an enterprise Visual Studio when I first started programming and only years later switched to Vim.

Which IDE do you use now? I am willing to give it a try, but most likely I already have.

Vim can be configured to show code errors (by integrating linters, static code analysis or "just" by integrating the compiler, or doing all 3).

Vim can also be configured to do auto complete. Actually I have not found a IDE that can provide Python (which I use a lot) autocomplete better or up to the standard that vim has and I have not found a IDE that can provide autocomplete for so many different languages.

Database work and debugging is something I mostly just use specialized tools for and don't have a need to integrate that into my text editor. Sure it was nice to just click and have a break point on that line like I did in Visual Studio, but that isn't something I miss.

Also: What do you mean by "modding down"?

All my opinion, of course.

I learned Python much better because I did not use an IDE.

I've written Java and C# using IDEs. I barely remember anything about their standard libraries. Python, in comparison, I know like the back of my hand. Thanks to writing Python in vim, I had to reference the docs, and eventually memorized them. Like vim itself, it made for a steeper learning curve, but the productivity gains in the decade after have been well worth it. I've since done the same thing with Go.

And that's not even mentioning that vim is an IDE - it's an extensible C IDE. Building with go-to-line errors? Yup. View definition? Yup. Syntax highlighting? Yup. The only thing it's missing is having the debugger built into it.

In the end, vim has the best features of an IDE without the bloat. It makes you use your brain when writing new code while giving you the ability to navigate your existing code with ease.

> I barely remember anything about their standard libraries.

If an IDE can abstract that memorization away from you, what's the problem? The benefit I provide as a software developer is to solve business problems and provide value to the people that use my product. Knowing the optional third parameter to a string method I use once a month off the top of my head really doesn't help me with that as long as looking it up isn't slowing me down.

I think the problem is always in the breadth of understanding. When you read documentation you discover more than exactly what you're looking for. When you tab complete something, it just tells you all the methods in the class that start with the letters you typed.

> If an IDE can abstract that memorization away from you, what's the problem?

It's more knowing what's available (do I have to use a 3rd party library for X task), and being able to fill in the parameters (as well as having those parameters ready) before the IDE prompts me for it.

Sure, pulling up the documentation isn't a huge chore in an IDE, but if I'm not prepared to give the third parameter a calculated length, I then have to go back and write more code before I can move forward.

It's also "how do metaclasses work" and "what types am I dealing with" and "how will this type be coerced in this situation" and "is monkey patching appropriate for testing this method".

Ultimately, it's about having sharp tools. My brain is a tool, and the more complete the picture of how a problem fits a programming language is, the more efficient I'll be at coming up with a working solution.

You would remember even better if you had to write the code out by hand or use punch cards.

I've only ever written C# using an IDE but I know plenty of things about the standard library. Why wouldn't I? I've written a bunch.

I use IntelliJ for certain tasks because I don't know Java as well as I should. It certainly makes me more effective as a guy who doesn't know Java very well!

I traditionally used vi for C coding (mostly for embedded systems in parallel with assembly, and then later on Vaxxen, and then Sun machines, and later Linux and embedded systems again). Part of the effect was "time-in-tool", but I certainly know C a lot better than I will every know Java.

I guess I would posit that I find the IDE invaluable to get up-and-going with a new language (and complex ecosystem of packages), I find out that I plateau out (learning-wise) at a lower level.

IF Java didn't have so much boiler-plate (esp. on Android), I'd probably have tossed it by now. But it does, so I haven't. I'm probably getting old and lazy and accepting my degraded knowledge set as a necessary cost...

Personally, I think IDEs are better for working but text editors are better for learning. If I'm using an IDE and need to call some method, I press press ctrl-space and more or less guess at which of the options is right. If I'm using a text editor and need to call some method, I go read the docs to figure out what the right method is. The latter is both slower and better for learning.

I spent a long time wrestling with trying to set up IDEs when I was learning. They were always a huge pain to set up, broke in confusing ways, and were generally far more effort than they were worth for the productivity gain (especially when I would try some other language/etc after a short period and go through it all again). Just using a text editor and the compiler was far easier to understand.

I still find some aspects of modern IDEs a pain, especially the fact that they either want to be your build system (and are generally crap at that) or lock you into a specific build system. Likewise I haven't found one IDE which can handle the variety of languages I use, so I need to learn 3, even if they all do basically the same thing.

I have some hope with the trend towards 'language servers' and also 'build-system servers' (though ATM cmake and Qtcreator are the only example I know of the latter), that this will change and you will be free to choose your combination of build system, development environment, and language with ease.

Try IntelliJ if you want something that works with a lot of languages and handles all of them really well.

Indeed, I use PyCharm as one of my IDEs. I may try CLion for embedded C/C++, but this is still restricted to ARM basically (and CLion supports CMake only, which is the least bad of the C/C++ build systems in common use, but still this is the kind of baggage that comes with an IDE which is not a problem with 'UNIX as IDE').

I think if you have IntelliJ Ultimate it combines the features of the various IntelliJ spin-offs.

Most of them, but CLion is an exception.

People are not sure what benefit is going to be provided to make up for the inferior text manipulation capabilities.

I remember tab completion being a big thing. When I was a new programmer, I really wanted that stuff, for sure. But as I see it now, I find the cases where I don't remember the name of the function I want to call rarer, instead wondering about the undocumented things like "is this method thread-safe?", "who owns the memory for this result object?", "what happens when the connection times out?", "does the error message this function returns contain the name of the file it couldn't open, or do I have to add it myself?" and so on, and the only way to find out is to open the source code of the library I'm using and to read it.

Like maybe IDE tooling has evolved to the point where it's just one keystroke to get the right answers to those questions, but I kind of doubt it. So if you want to demean people for not using an IDE, you need to sell it a little better and tell us what we're missing. If it's just tab completion and a shitty build system like IDEs were 10 years ago... not interested but thanks. If there is something that's actually helpful though, would consider.

What inferior text manipulation capabilities?

I've always found basic text manipulation lacking in the GUI apps I've used. "Make this comment fit in 100 columns without losing paragraphs" "move the next line up to the end of this line" "go to line 647" "move the cursor to the beginning of this method" etc.

My knowledge dates from the "one keystroke to convert this to a JavaBean!" era, though. I'm guessing people don't do that anymore.

I just have IntelliJ configured to use Emacs key bindings; vi ones are also available for people who use the wrong text editor.

The default Emacs keybindings are nice, but do the semantics transfer (mark/point and associated manipulation functions), and can you write your own functions? I don't have a _ton_ of custom elisp functions for raw text manipulation, but the ones I have written are useful and I wouldn't just give those up for no reason.

There are also a lot of dumb keybindings in Emacs that should not be copied by anyone (looking at you, C-u - 1 M-z X to delete all characters backwards to the first X.).

The semantics are pretty good with the IDE I use most often, IntelliJ (for instance you definitely do have marks, there is a sensible kill-ring-like functionality for M-y, etc.). Writing a custom function is harder (I think you've got to write an extension, basically), but there are a lot of other useful things you can customize (making up your own templates, for instance). Also, the deeper understanding the IDE has of your code compared to Emacs lets it make many more useful suggestions for issues and potential refactors.

Every IDE or text editor I have ever used had very limited text manipulation and navigation capabilities.

The only exceptions are VIM and Emacs (and editors that follow that spirit, like Neovim).

Vim especially has an entire language of text manipulation and navigation features. This language is made up of actions (like c for change or d for delete), Motions (like hjkl for left, up, down, right respectively) and Repetitions. These elements can be combined into very powerful commands, especially since there are a lot of Actions and Motions that can be performed. This is made possible by the Modal Editing[1] that Vim provides. You would simply type these commands in "Normal Mode" and then you would be dropped into "Insert Mode" if necessary.

At first this might seem very silly or inefficient, but after a while it becomes almost second nature and is more efficient then using the mouse or pressing Arrow Keys 100 times. Especially if combined with the Macro capabilities and the Search Commands.

Some examples of this language:

Navigate 10 lines up: 10k

Navigate 10 lines down: 10j

Go to the beginning of the next Method: ]m

Change the word under the cursor: cw

Change the paragraph under the Cursor: cip

Change the inside of "" pair under the Cursor: ci"

Change a pair of "" after the Cursor: ca"

Change the inside of {} pair under the Cursor: ci{

Visually select the text from the cursor until the 3rd occurrence of the character x going to the left without selecting the x: v3Tx

Same thing, but going right: v3tx

Same thing, but going to the right and selecting the x: v3fx

Same thing, but change instead of visual select: c3Tx

Same thing, but do a rot13 "encryption" after selecting: v3Txg?

[1]: https://unix.stackexchange.com/a/57708

This stuff is all supported by IDEs, though. e.g., https://github.com/JetBrains/ideavim

These kind of Vim emulators are not really providing the full vim experience. Some come close (like Emacs Evil Mode), but most just don't. Most are just scratching the surface of stock vim.

Not even the vim experience when using plugins, just stock vim.

I tried ideaVim and while I do not remember what my specific problems where, you can read their ReadMe for a glimpse that they have a lot of issues still.

Even IF they would provide a decent enough vim emulation, why use something emulated when I can have all the IDE features in Vim itself.

Also: Vim plugins that provide IDE features are purposefully build with the way vim works. Providing advanced IDE functionality in a Modal Editing environment. This can not be said about an IDE with vim emulation. As far as I can see they implement those features as ":action <actionName>" which is so much worse then what vim can do.

IntelliJ + IdeaVim is simply a worse Text editor then Vim despite being significantly more bloated and slower and I would even say that Vim with plugins is a much better IDE as well (while STILL being less bloated and faster).

I was always more of an Emacs guy so I can't speak to that specifically, but in your big list of examples there's nothing that wouldn't work, as far as I can tell.

Been doing all that happily for years with IdeaVIM. And still retaining access to the things that are nice in a graphical environment.

IdeaVIM is not good. I have tried it and for me it just pales in comparison to just vim. I can get all my IDE features in vim anyways.

I don't use java though, so maybe that would be different if I where using Java.

I can't get the features of VIM in an IDE. I CAN get IDE features in VIM.

I get syntax highlighting, Automatic Checks, Navigation based on Language structures. I even can integrate my shell and debuggers into VIM, but I don't use do that. I use those usually just as a stand alone tool.

VIM and Emacs also have the absolute best git integration I have ever seen. Magit for emacs and Fugitive for Vim are absolutely fantastic. Certainly beats any IDE I have ever used.

I can't think of anything that I would like to have from any IDE.

MY vim is a much better tool for me then any of the IDEs that I have used in the last 10 Years. I started out with IDEs, because that is what my teachers and mentors used, but once I learned vim the IDEs just seem painfully slow and limited.

It is also not the case that I just don't know better. I certainly have used many IDEs in the past. For example I used Visual Studio (Not "VS Code", the proper enterprise VS) for 2 Years.

That's false though. You totally can get the features of vim in your IDE.

I run Emacs, in GUI mode. If the language tool have a debugger and/or an interpreter, there is the IDE. In the rare case that there is not a ready made comint implementation for a language, it's easy to do. Completion, well M-/ is good enough. If I don't know a function's name, I need to read the manual to find it and to learn what it does anyways. If I need snippets, it's easy to define them, even without an Emacs minor mode for snippets. Every part of the system is extensible, every keybinding redefinable, and almost every functionality composable. And almost any programming language with more than ten users has an Emacs major mode already made for it. If I really want semantic completion or on-the-fly error reporting and linting (I don't use these out of preference), it's dead simple to integrate and enable.

Not only, but I can use the same thing to read my mail, maintain my agenda and create and edit documents.

With an IDE, I need another IDE for every language I use. Then I still need a text editor for editing text anyways. Each editor has it's unique method of customisation, and its conventions, its own keybindings, its own behaviour &c, and its own way to store customisations, which are hard to version control, if possible. And substantial customisation that requires custom code is either impossible or very hard to do.

Emacs is an IDE for Emacs Lisp. But it's so naturally extensible that it's become an application platform, basically. If all you do for all your career is to write in one language or two, then go with an IDE, I guess. But I'm glad I can use the same program to edit Perl, Python, Ruby, any sort of text, HTML, C, Assembly, Ada, Cobol, JavaScript, CoffeScript, Clojure, ClojureScript, Java, Kotlin, Scala, Haskel, and so on; and do way more with it than editing source code.

An IDE gives you:

1 - Autocomplete and automatic code, those are the main benefit. Turns out that if your computer can write code for you there is something wrong with either your language or your code. Code generation is a bad replacement for code abstraction.

2 - On the fly error checking. Turns out that vi and emacs do that too.

3 - Coherent access to compiling and debugging tools. As long as you want to use the IDE tools and nothing better, at the price of loss of productivity every time you must reconfigure it, or share an environment with anybody.

4 - In place documentation. Again, vi and emacs do that just fine too.

If you are using a language that requires an IDE (that's a big language flaw, but most people don't get to choose), and wants to use a very standard and non-extensible toolset, go ahead and get that IDE. But the people disagreeing with you, it's not they that don't know something.

The on-the-fly error and smell checking Emacs does is better than nothing but it's on a different level than a good IDE.

Hum...

It marks the failures found by the CLI compilers and linters, exactly like any "good IDE" out there. What IDE are you referring to?

I'm mostly an IntelliJ (and variants: RubyMine, Webstorm, Rider, PhpStorm, etc.) user, although I also use Visual Studio. In my experience, Emacs plugins for many languages often have a feel of working more on looking for matching words in the code rather than "understanding" what the code is doing, let alone suggesting good refactors.

IntelliJ's linters are indeed unusually rich on the deepness and complexity of their rules. But not on the universality, the reason that I consider them unusable, since I just don't like to turn rules off.

Anyway, that's a feature of their linters. It just happens to be packaged with their IDE, but it's a completely different tool.

In practice the great linters and refactoring tools are kind of a package and it's nice to have them integrated (there's the "I") into your development environment. I find the IntelliJ emulation of Emacs key bindings good enough for me.

Want to try the best of both worlds?

Right now, you can experience ide-level autocompletion and type-checking in vim if you are working with typescript and have typescript-vim plugin.

Just do one decent sized software with typescript+vim. Even intellij ides seem like bloated and inefficient software after that.

PS: gvim is fine too. Easier copy to, and paste from clipboard.

Just to add to that: Vim has ide-level autocompletion and type-checking for many languages and not just typescript.

I don't think they need to be mutually exclusive. I use both daily. I don't use vim emulation in anything else and the context switching hasn't tripped me up in a long time, it was a bit of a problem at some point though.

Out of curiosity, how long using an IDE did it take you to get back to the productivity you had with Vim? Also what IDE is a good replacement for Vim?

(I tried a couple of times switching to Eclipse but was too frustrated so quickly got back to Vim)

i've used a mix of ides and text editors over the years but i've committed entirely to emacs for the last 6 or 7. the value of having a tool that i can adapt to my needs and use anywhere for anything greatly outweighs any capricious ide conveniences.

Reply on news.ycombinator.com