Tutorial :Why Emacs/Vim/Textmate? Isn't Xcode good enough?


Hi I mostly do C++, Objective-C programming. And I found Xcode plus an auto completion/macro plugin (Completion Dictionary) quite adequate.

However, all people seem to praise over their pure text editors. I tried Textmate for a bit; liked its simplicity but dislike its files/framework handling.

Am I missing something here? Or, do Vim or Emacs have auto-completion as good as Xcode?


Pull up a chair son, let me speak on this.

Well before the days of Xcode, there was VIM and Emacs. I know it's hard to imagine, but it's true.

Many people got accustomed to VIM/Emacs, and thus continue to use it.

Emacs is extremely customizable, and offers pretty much everything you can imagine (including a built in shrink and the towers of hanoi). You can easily call compilers from Emacs, and create your own extensions as needed.

VIM has incredible regex engine (Emacs does as well) and is very handy because (VI) comes with pretty much every Unix OS, and works fantastically if you don't have arrow keys (yeah yeah, real old school). People are very good with using keys to move around documents, without having to use the mouse.

The same is true with Emacs as well, but for me, I find cursor motion much easier on VIM.

The text editor war is fueled with as much religious zealotry as the Mac vs PC war, and the answer is pick the best that works for you. If you like Xcode, great, continue to use it, however good luck if you're ever forced to work on a PC or Linux machine. Personally, I use Emacs to code, VIM to manipulate text and Firefox to look at lolcats.


I really don't understand why emacs props up when people talk about text editors. In my experience it's more like eclipse (or one of those other platforms/IDEs) than vi because it is an environment, which happens to be good at text editing.

As an IDE emacs features version control, live compilation, spell checking, auto completion, debugging, code browsing and lots more for a wide variety of SDKs. For the rest of your computing needs it's an email/news/web/irc/twitter/xmmp client, calendar, organizer, calculator, terminal emulator, remote editing, speadsheets, games etc. etc. etc.

After Dijkstra: "Emacs is no more about text editing than astronomy is about telescopes"


What you are missing is that Emacs and Vim are actually IDEs.


vi is ubiquitous on UNIX systems, and Emacs almost so. AFAIK, Xcode is on one platform.

Having a powerhouse IDE is a great thing, but everyone should have a smattering of skill to keep them functional on any platform they might be dropped into.


It's all up to your preference.

Some people like to work with lightweight texteditors like (g)vim, emacs, pico, etc. Others like to work with IDEs like MS Visual Studio, Eclipse, Xcode.

As long as your environment is compatible with the text editing technology, it's all up to you.

By the way, I like working with Eclipse and vim because they are what I used to learn programming ;)


The main reason you seem to think people like Emacs/Vim is for code completion. People like Emacs/Vim cause they are both MADE for editing text. You have control and options available to you that other editors just don't have. Once you get REALLY good at using one of these programs you want these key bindings / commands available everywhere. Macros, regular expressions, moving around by search/word/paragraph/function, interfacing with version control, complicated undo/redo and copy/paste functions and extension options are just a FEW of the things that these editors do really really well.

Code completion is just one of MANY things that can make writing programming easier. Emacs/Vim can handle ALL of them (natively or by exntensions).


No, not really. It's a matter of preference really. I liked working in Visual Studio 6, but nowadays the newer versions are just too bloated. So if I can do something outside VS I usually do it without opening the whole IDE box.

On windows I like notepad2 and gvim. I've customized vim to the point where it suits my needs perfectly, so I don't have to think about what and where.

But, it's good to mention that (you could also figure that out by yourself by reading these kinda posts) a lot of users uses vim/emacs/... 'cause of the heard-its-the-best/cool-factor/actual-usability. So if it doesn't suit you, don't use it. Nobody's gonna look you the wrong way cause of that.


For me most the two most important features are:

  • Emacs key bindings, as that is what my fingers are compatible to.

  • Open-source, for the freedom it provides. Being tied to one platform is anathema.

These days I mostly use Eclipse for programming (set to Emacs keybindings) and FSF Emacs for reading mail and some occasional LaTeX.


I personally love emacs. I've used vim and a handful of IDEs. Vim and emacs both have great communities where people are willing to code up features for just about any language. I don't know of any IDEs that, say, support Haskell. It all depends on what's important to you. Both have extension languages, though IMO, emacs lisp is the better of the two. The ability to ignore the mouse is the main thing I like as well. So many IDEs also feature emacs and vim compatibilty modes or extensions. They both have a large time investment, but both are worth it. Sooner or later, you will choose which suits you, vim/emacs/IDE, and then stick to improving your skills with it.


When you are using Emacs, you can install Cedet or Autocomplete package to use name completion for some languages (C++ is pretty good, while Obj-C is still not supported), in addition to rich editor functionality


emacs is powerful. I use emacs with vimpluse.el so that I can use the vim key bindings with all the emacs features.


I use Vim mostly for the input model. Once you have become proficient in the input model, going back to an editor where you are forced to use a mouse feels clumsy and ultimately (at least to me) irritating. It is a lot more efficient to type "ci'" to alter all the text between two single quotes, then taking your hands off of the home row, finding and selecting the text with the mouse and finally hitting 'delete'.

I have only used Emacs briefly and while I prefer Vim, I am jealous of some of its features. But I ultimately went with Vim because I find the chord-input model that Emacs uses to put unnecessary strain on my fingers.


I have Xcode and TextMate and I don't use them although I know they can be very powerful. Instead I use Vim (or MacVim if you prefer). Why ?

Because it's light, fast, addictive, powerful, customizable... I could go on like this for a long time but the most important thing is that I can do all I want with Vim.

Whatever the editor you use, the best editor is the one you master (almost) perfectly.


TextMate just feels lighter to me. Off the top of my head:

  1. It has great support for jumping between files and methods within files. Think Quicksilver for files/methods. With a file open for editing, hit command-shift-t to bring up a floating panel listing all the methods in the file. Start typing and the list filters itself down. Select the method you want and hit return to jump to it. Xcode has something like this but the sting matching is more literal.

  2. Lots of built in text expansion. Type a trigger and hit tab to have it expanded. For example, on a new line typing m and then hitting tab creates a method for you. The tab key then intelligently jumps to the various parts of the inserted text so that you can edit them in place. These are such a huge timesaver it's ridiculous.

  3. Nice plugin support for Subversion and Git. Probably other VCSs too.

  4. Completions (like Xcode) and history. TextMate allows you to tab-complete basically any text that exists in the file. So once you type a variable name or method call once, you can use tab to auto-complete it anywhere in that same file.

  5. Smart past board with history, nice built in diffs, theme support, good keyboard support, find in files and across projects (with RegEx) and probably more that I'm forgetting.

Anyway, that's enough from me.


I am a long time vim user, and find that I really like Komodo edit with the Vim emulation turned on. Thus, I get all of convenience of the vim key bindings (to which I have become so accustomed that a recent MS Word document that I recently produced had no less than three ":w"s in it) plus the well implemented code completion for C++, Python, javascript, etc.

I don't use XCode because I don't develop OS X specific applications very much and so the benefit of the OS X framework integration isn't large enough to outweigh the cost of not having vim key bindings and the "do it our way or not at all" approach that Apple takes toward development.


Xcode is more of an IDE, whereas emacs and vi are for pure text (though they have massive extensions to them). This is preferable if you're on an older system or over an SSH. In addition, they're pretty much on every UNIX based computer, whereas XCode is proprietary Apple software.


I don't use vi to do my coding; however, I do, when available, use vi emulation in my editors. When I am doing Java coding in IntelliJ I use the IdeaVIM plugin which gives me vi support in IntelliJ's editor. This means I almost never have to take my fingers off of home row. I navigate with the keyboard (h,j,k,l), cut/paste with yy, dd, etc. And of course when I do need the power of a full feature GUI editor vi emulation doesn't keep me from using those features.

It drives me nuts that XCode doesn't have vi emulation in its editor. Seems like functionality that any decent IDE should have.


Personally, I love TextMate, because it's actually a really lightweight solution. Granted, I have not used Vim or Emacs in depth (I like my GUIs)...although I do thoroughly enjoy the Control-based cursor navigation (Control-A is beginning of line, Control-E is end of line, Control-F and Control-B are forward and backward, etc). So between Xcode and TextMate, I use Xcode for most of my serious development, but if I just need to quickly edit a source file I can be up and coding before Xcode even finishes launching (it helps that TextMate can remember which files were previously opened and restore them). So for some lightweight text editing, TextMate is my choice.

Above that, TextMate's plug-in support is amazing; it provides full support (syntax coloring, building & running, etc.) for so many different things (shell scripts, CSS, SQL, LaTeX, and much more) that Xcode doesn't provide. When I need to brush up a quick program in Java or tweak a webpage, it's a lot easier then using Vim and then building from the Terminal.

My only complaint with TextMate is that the console is read-only, so I can't build anything interactive. That, and the fact that it doesn't seem to support C99 keywords (for loops and booleans) in a plain-C file.


You might have a look at my essay on the subject Why Emacs?. While it's more or less Emacs-centric some of the points made in it would apply to vim and TextMate as well.


I tried vim a long time ago and for one reason or another "I didn't get it". Then after trying other editors over the years I reached a point where no editor seemed to do what I wanted it to do. After voicing my frustration to a friend he recommended that I try vim....and I am so glad that I took another look because it was the answer to a question that I didn't know how to ask! I have used Vim/MacVim ever since...

here my configuration: https://github.com/RandyMcMillan/QuickVim

I use Xcode as well because it is nice to have code completion. XVim is good for people that want a modal/vim feel in the Xcode editor: https://github.com/JugglerShu/XVim

But when it comes to my day to day editing Vim wins every time. That is why I have the QuickVim repo is so that I can quickly reproduce my environment anytime/anywhere.

I have a list of licenses for editors like TextMate, etc..but it is likely that I won't ever use them since I can use vim for free and customize it to my exact specifications.


Heavy Vim user here. I generally find the text manipulation capability of Vi/Vim far superior than traditional editors which lack things like:

  • visual mode: e.g. prefixing 5 lines with comment //
  • macros: e.g. surround 3rd to 5th words in a line with quotation marks, repeat for 100 lines
  • multiple registers: think 36 registers to copy and paste
  • delete{motion}: e.g. delete from cursor up to the next occurrence of 'initWithFrame'

These are just a few examples that Vim has XCode text editing beat hands down

For Objective-C. I tend to install a Vim plugin on the IDE to get the best of both worlds - native build / UI components support.

Incidentally. Emac keyboard bindings (e.g. CTRL-A to go to top of line) are supported in a lot of native (Coacoa) text fields on Mac. Including the one you're using for typing answers on stackoverflow :D

XVim works with XCode. IdeaVim for AppCode

Note:If u also have question or solution just comment us below or mail us on toontricks1994@gmail.com
Next Post »