Hacker News Reader

Comment by BipolarElsa | Hacker News Reader

I have a question: what's the benefit of using a text editor when an IDE can perform compiling/interpreting for you at the ready?

Is a Emacs/Vim for coders who don't have to worry about minor errors?

I'm relatively new to programming and I'm curious.

View on HN

We detached this subthread from https://news.ycombinator.com/item?id=13073839 and marked it off-topic.

A text editor will always be with you, no matter what you're working on. IDEs tend to be for a specific host platform, language, and sometimes target platform. For example, Xcode only runs on a Mac, understands a limited set of languages, and is best used for building Mac and iOS apps. MS Visual Studio only runs on Windows, understands more but different languages, and is best used for building for Microsoft platforms. Android Studio is best used for Android things. IntelliJ and Eclipse are best used for Java.

If anyone has heard of your programming language, there is probably an Emacs mode for it.

More to the point, Xcode, Visual Studio, Android Studio, IntelliJ, Eclipse, and so forth all have generally different UIs, which means that unless you spend all your development time in a single environment, you have to do a lot of really expensive mental context switching.

An editor like Emacs or Vim provides a unified user interface for all the different languages and development environments with which you use it, which eliminates almost all of that mental overhead - and can also invoke your compiler, (usually) integrate with your debugger, et cetera. IDEs still win on tight integration, but for any language popular enough that someone's invested the time to build a well-integrated IDE for it, Emacs or Vim will generally cover at least the 90% cases quite well, too.

Although often, is not very good. The Emacs support for C++11 was awful for years. May be better now, I left Emacs because it.

https://github.com/Sarcasm/irony-mode

If I ever try Emacs again, I'll have a look. In the past I've found clang-based plugins seem to have a half-life of about 6 months.. while Emacs might live forever if your plugins don't, then you are relearning a bunch of things anyway.

PS at first i thought your URL was some kind of joke I didn't get, until I clicked it and found it linked to a genuine project.

Emacs users don't have to worry about minor errors because we don't make them. Vi users don't, either (they already made a huge error, so all their little ones don't matter).

On a more serious note, a lot of the features of an IDE (e.g. code completion, method lookup, compiling, and version control integration) are trivially turned on with emacs. I use etags (ctags, etc) and have macros bound to various frequently used git commands, auto-compile when I change a translation unit, etc. My Emacs is an IDE. And much more. Vi has similar functionality available to some degree or other and even if it didn't, with evil mode in emacs vi users can have it, too.

Most if not all IDEs separate compilation from the actual editing. So choice of editor is really orthogonal to whoever is doing the compiling. Ideally you want to be able to do this all from the command line anyways so you can run automated tests when code is checked in. Vim and Emacs can be set up to emulate a pretty convincing IDE experience, but the separation between editor and compiler is much more clear.

To reverse your question: why require an IDE if the same tools work on the command line too?

Vim is pretty much an IDE. I type :make (not :!make) to build. Vim gathers the errors into a quick-fix list, and navigates through them. I have Vim's :grep bound to doing lid lookups on a mkid-generated database: lightning fast to find all occurrences of an identifier. And of course tags for chasing identifier definitions, thanks to a ctags-generated database. Vim has very good syntax highlighting and indentation; many times I spot as syntax error because it is flagged by Vim. I also have a Vim add-on that performs code completion. I type foo. and the list of members of structure foo come up, etc.

I don't step-debug inside Vim; but it looks like there are ways:

http://vi.stackexchange.com/questions/2046/how-can-i-integra...

Emacs is not a text editor, this is a common fallacy.

It's an entire environment, the closest thing that we have today to the Lisp Machines of myth and legend.

An editor is simply one of the many applications it runs on top of the Emacs Lisp core.

At least for Emacs, one of the things I like about it is the ability to add functionality when I need it. For example, implementing a "go back to the last place I modified this file" (super useful to me, at least) and then binding it a key would likely be hard to "add" to an existing IDE. With Emacs, not so much.

It's also very easy to add ad-hoc functionality directly from the editor. You can start with a keyboard macro (F3, do crap, F3, do crap, F4, hit F4 again to do "do crap" as many times as you want) and go all the way up to writin elisp packages. M-x find-function makes it easy to look at the internals of whatever library you're using. defadvice makes it easy to do horrible, but expedient, things and get on with your life. IMHO, if you're not writing at least a little bit of elisp, you're not taking advantage of Emacs's real potential.

The thing is that an editor is one of the tools that a programmer uses. We also use build tools, debuggers, profilers, visualisation tools, etc, etc.

IDE stands for "integrated development environment", but to do the "integration" part, what it usually means is that it bundles tools for you. So you are stuck with the editor, debugger, build tool, etc of your IDE. Every time you choose not to use that "integrated" tool reduces the value of the IDE.

For example, if you decide to write your own build files and start the build process off differently than the IDE expects, it's no longer "integrated". If you decide to use a different debugger, it's no longer "integrated".

Primarily, choosing not to use an IDE is mostly about wanting to be flexible about the tools you are choosing. Sometimes the tools in the IDE are really good for your job (for example, some of the refactoring tools can actually make certain IDEs worth it alone in some environments). Other tools, like the simplified build systems, almost always cause more trouble than they are worth in the long run.

When you get down to think about it, how difficult is it to "integrate" a custom set of tools without an IDE? We are programmers. Especially programmers who come from a Unix background are very much used to building their own environments. It's not nearly so hard as it seems -- especially because most of the heavy lifting has already been done by people before you.

In the case of Emacs, it practically is an IDE, except that you can plug damn near anything into it with a little elbow grease. I know of programmers who never leave Emacs. Ever.

So to sum up, there is almost nothing you do in your IDE that I don't also do in my custom built DE. My biggest gripe about IDEs is that I wish they would unintegrate their tools so I could use them separately :-)

What makes you think Emacs cannot do proper syntax checking for me? Just install the right package with the package manager.

You should be able to edit text in a familiar manner regardless of what kind of text it is. It might be source code, or it might be an email, a webpage, a document, your shell, a debugger, or anything else you can think of. No matter what you're editing you'll have the same features, keyboard shortcuts, etc available.

A programmer who wants a good universal text editor will find one that also has good integration with their compiler and debugger; emacs and vim are both pretty good choices there.

Reply on news.ycombinator.com