I have, however, come to realize that navigation through a large project with keys alone is suboptimal. One typo in a nav command and you have to press at least four or five more keys. With the mouse, you're less likely to make such mistakes and your retry time would also be low. It'd be like trying to browse the web using the keyboard alone... even I, a hardcore vim user, found firefox/vimperator underwhelming to say the least.

What would be awesome is if they made some sort of hybrid superintelligent keyboard where the whole keyboard surface could also act as sort of a multi-touchpad. As a compromise, I've found that the thinkpad-style pointing stick in the middle of the keyboard does a fair job.

Practically, this means that whatever file you think of, you can type any part of its name at any time to get to it. Once I got used to working this way, I stopped using the project tree-view: it's just much slower.

Highly recommended, they both have a smart open file that lets you start typing a filename, and smart goto, which lets you start typing a class or method name. Makes navigation so much faster!

To some extent you'll need mouse-interaction, for dragging things and clearly visual stuff like that (nobody likes to position things with the keyboard, or at least they shouldn't), but they should really do their best to add keyboard hooks to almost everything that they can, definitely.

Any IDE worth its salt will do all the things in that video, except for the little draggable bubbles.

Yeah, because we have to type M-. to navigate to the related code.

(Also, insert rant about how "UNIX is my IDE".)

Can Emacs give me a hyper-linked list of all usages of a given symbol and do it properly(lexical scope, etc.), not just doing a simple symbol search?

Can I edit my code in emacs, have a background compiler compile the file on the fly, and also provide error feedback, hilighting the problem lines with a tagged failure reason and also providing a hyper-linked list in another window as well? Last I checked, the best I could do would be to kick off a compile manually and navigate the errors as a linked list.

How's emacs' refactoring support? Judging by the following stackoverflow post, it's pretty poor: http://stackoverflow.com/questions/673554/how-can-i-refactor....

How's Emacs' keyword completion? Last I checked, it was just a hacky dictionary look-up, whereas an IDE can semantically analyze the source to provide intelligent suggestions.

Even if you can get Vim or Emacs to do some of the above, it usually isn't as easy to use or as useful as an IDE. For instance, I know you can get call graph support in Vim using cctree.vim, but it relies on cscope, which requires refreshing the database manually, is slow to load, and tends to generate incomplete tag sets.

IDE's are, well, better integrated, and so can do many things a lot better than looser environments like Emacs and Vim. Their UI's tend to be a lot more powerful because they are not designed to be run on windowless environments. Personally, for small projects I use Vim and for large projects I use an IDE with a Vim emulation plugin like Netbean's JVI plugin.

Yes. You're looking for Cedet. Can your IDE read my mail?

> Can Emacs give me a hyper-linked list of all usages of a given symbol and do it properly(lexical scope, etc.), not just doing a simple symbol search?

Yes. You're looking for Cedet. Can your IDE integrate with your calendar?

> Can I edit my code in emacs, have a background compiler compile the file on the fly, and also provide error feedback, hilighting the problem lines

Yes. You're looking for `flymake-mode`. Can your IDE email who created the error using version control information?

> How's emacs' refactoring support? Judging by the following stackoverflow post

Stackoverflow gives retarded answers sometimes. The next best suggestion on that page is correct. Cedet is great.

> How's Emacs' keyword completion?

It's fine. You can complete symbols sensitively, and complete filenames or email addresses from anywhere. Having multiple completion systems is very useful. How's your IDE's ability to complete those things?

> Even if you can get Vim or Emacs to do some of the above, it usually isn't as easy to use or as useful as an IDE.

You don't need to be so hostile. Emacs does these things just fine, and has for a long time. Emacs also does my time tracking, outlining, and email. Your IDE won't do any of those things, and you don't expect it to because you think those tasks are best left to other parts of your operating system.

The thing you're missing is that for Emacs users, Emacs is the operating system. I dual boot into Firefox sometimes.

I would be interested in seeing similar environments for C#/Java as well as for dynamic languages like ruby/python/php, which IDEs have also been handling very well lately. I've also noticed in general that it's difficult to make an IDE for c/c++ that works better than editors. They compile slowly, The macro system severely complicates quick parsing, C++'s grammar in particular is very difficult to parse and analyze, the languages do not make run-time loading of code easy, and they don't provide much in the way of RTTI. In short, they are not very IDE-friendly languages. Java and C# are the perfect IDE languages, and dynamic languages suffer from not providing enough static information.

This isn't helpful.

First of all, Emacs is an excellent IDE for Lisp and has a built-in debugger, sensitive completion and automatic documentation, while Visual Studio can't do any of those things you thought were important until you install Visual C/C++.

Is Visual Studio "just" a editor with a plugin system?

Why are you so interested in giving emacs such a negative label?

> I would be interested in seeing similar environments for C#/Java as well as for dynamic languages like ruby/python/php, which IDEs have also been handling very well lately.

For python, there's Ropemacs: http://rope.sourceforge.net/ropemacs.html

For perl, there's Sepia: http://cpansearch.perl.org/src/SEANO/Sepia-0.97/Sepia.html

I don't program in C# or Java or Ruby or PHP regularly so I don't know about them off the top of my head.

> Can your IDE integrate with your calendar? Yes. > Can your IDE email who created the error using version control information? I don't know. But I'll give it a qualified yes bes cause this is generally handled by the build script, which is IDE-agnostic. > How's emacs' refactoring support? Judging by the following stackoverflow post Stackoverflow gives retarded answers sometimes. The next best suggestion on that page is correct. Cedet is great. > How's Emacs' keyword completion? It's fine. You can complete symbols sensitively, and complete filenames or email addresses from anywhere. Having multiple completion systems is very useful. How's your IDE's ability to complete those things? I don't see anything, so perhaps they don't exist.

But this is silly. We're developers. Using IDEs designed to be extensible. There is very little we couldn't do if we wanted to. Emacs has been around forever, and it has tons of stuff available for it. It also favors a different working style than something more GUI-based, which some prefer and some don't.

There are tons of great tools out there. It's a great time to be a developer. > Even if you can get Vim or Emacs to do some of the above, it usually isn't as easy to use or as useful as an IDE. You don't need to be so hostile. Emacs does these things just fine, and has for a long time. Emacs also does my time tracking, outlining, and email. Your IDE won't do any of those things, and you don't expect it to because you think those tasks are best left to other parts of your operating system. The thing you're missing is that for Emacs users, Emacs is the operating system. I dual boot into Firefox sometimes.

Hyperlinked call graphs: nope. Never needed it, don't know how to generate them for any language I use. Emacs can't do it, but neither can anything else. Write the code to do the work, and Emacs will support it in about 30 seconds.

All use of a given symbol: same problem. The static analysis for this is Really Hard, and it would provide me with near-zero value.

Background compilation: yup. Supported by pretty much every mode.

Refactoring: I've used Eclipse, but I've never had good luck with its refactoring tools. The automated refactorings are almost what I want, but since exactly what I want is so simple, I just do it manually. If you are renaming your classes everyday and you have to change the name in 1000 files, you have two problems that can't be solved by an IDE.

Keyword completion: excellent. I was using Eclipse today, and there is a noticeable delay between when I press M-/ and when the keyword was completed. I eventually learned to not use that feature, because I can type faster than the auto-completion can "intelligently select" the right keyword.

Emacs is instantaneous, and right as often as anything else. And I can expand things other than symbols, like long words in the documentation, or filenames in string literals, etc.

As for integration, I find Emacs to be quite well integrated for the work I do. A few weeks ago, I was writing a Haskell app for use on Windows. I was really not looking forward to it, until I realized that all the Haskell functionality works perfectly on Windows. I never needed to leave Emacs; I could test my code (interactively or automatically) from the GHCi REPL and I could build binaries and docs with M-x compile. Of course, it's just one keystroke to move to compilation errors (in both cases). If I needed to poke around in a shell, I just used Eshell, which works the same on every platform. Everything you need to do is tightly integrated and very fast.

Working with Perl is just as nice; one keystroke runs the test suite in a nearby eshell, another just runs the tests that pertain to the current file. Anything I want to do is usually one or two keys away, and a shell to do something complicated is just as easy to get to. (For me, C-x C-x switches between the shell and the most-recently-used buffer. Fast!)

Their UI's tend to be a lot more powerful because they are not designed to be run on windowless environments.

Not true. But one thing that's nice about Emacs is that you can run Emacs in the background and connect to it multiple times. If your X session dies, no information is lost. If you are poking around in a shell, you just "emacsclient -t file" (which I alias to "ec file") and you are instantly working with that file in your normal Emacs session.

for large projects I use an IDE with a Vim emulation plugin

That means you are probably unaware of about 90% of Vim's features. I've watched many experienced Vim users try to use various vi emulation plugins for Eclipse, and there is always a lot of cursing involved. They eventually just invoke Eclipse functions from vim instead.

The underlying theme here is that IDEs make tasks that you perform once or twice a week really simple. The "traditional editors" don't do much about that; instead they make the things you do 10,000 times a day really really simple.

(One other thing I notice is that IDE users tend to ignore features that Vim and Emacs have and dismiss them as unnecessary, while Emacs/Vim users steal the good features from IDEs as often as possible.)

In conclusion, you don't know much about Emacs.

You're right that I don't know a lot about Emacs. In this thread in particular I've learned about CEDET and flymake-mode, which seem to apply to C/C++ and maybe Java and C# to some extent and add a lot of useful IDE-like features.

- I think that different languages (and programmers) suit themselves to different balances of the IDE/Editor combination. I agree with your post, inasmuch as I find writing Java outside of an IDE like Eclipse limits you greatly. It sounds like you write Java a lot.

- OTOH, I find writing C/C++ in Emacs with cscope/etags/make support and some custom keystrokes, and functions for common Unix calls, is about as good as any IDE can get you for those languages (although I admit that I've only had limited C++ IDE experience, using Visual Studio.)

Yes, you have to do custom configuring to get Emacs working well. So, it's a small amount of extra upfront work over Eclipse. The upside is that you get to customize it however you want. In Eclipse I'm still using most of the default configuration, for the simple reason that it works "well enough"

I find writing Erlang in Emacs erlang-mode is fine as well, mostly because the language doesn't encourage me to create the kind of horrible architectural behemoths that you _need_ an IDE to manage.

The difference between Language-oriented and IDE-oriented approaches to programming was laid out really well in a recent blog post that made it to HN, but I can't find it with a quick google - sorry.

Thanks for the tip.

It's just not a mouse-based IDE. Mouse clicking makes my hands hurt much faster than using the keyboard. I also find it annoying to switch from mouse<->keyboard, so I don't want a UI that relies on constant mousing.

Saying "Emacs can do whatever you want" is like saying "your computer can do anything you want." Sure it can, so long as you're willing to write the code to make it go. But my time is finite; I cannot be bothered to re-build environments that have already been implemented elsewhere.

It's true that some things are lacking, so it's too bad that whoever wrote the code that does your high-level syntactic analysis didn't make it independent enough that it could be used in other places than whatever IDE you were referring to.

Yes, I've used ctags and I've used etags. They tend to be interesting approximations but are never 100% reliable. They don't do a deep sematic analysis of my program. (For example, they don't understand C macros.) They don't update as I type.

The closest I've ever seen has been the "Semantic Bovinator" thingy. I have never managed to get it to run, nor has anybody I've seen try. You experience may be different, of course. (I realize that by posting this I'm inviting a raft of people to post and say "It works for me!" :) )

SLIME has this in Emacs for Common Lisp and perhaps other languages that work with SLIME.

I'm on a non-multitasking phone now so you'll have to do the googling yourself.

We might use different technologies. I mostly write Objective-C, Ruby, Python, C, JavaScript, and recently some Objective-J and Erlang. Now and then I write Lisp (CL, Emacs), Scheme, Haskell, x86 assembly, and PHP. The only one of those I don't write in Emacs is Obj-C.

Other editors or IDEs may be better at certain tasks, just as Emacs has unparalleled Lisp support with SLIME. When there is clearly a best tool in one field then people tend to use that tool, if the payoff is worth it. Except for pg and a few others, people generally write Lisp in Emacs. I write Cocoa and Cocoa Touch apps in Xcode and IB. I'm pragmatic about it. But when I tried to use Eclipse for Mojo (webOS) because Palm recommended Eclipse + Mojo plugin, it ended up being more productive for me to extend an existing Mojo mode for Emacs[1] to have even more features[2] than the Eclipse plugin (or any of the others, Komodo, etc). Similarly if I were doing Java I would at least look into IntelliJ IDEA or Eclipse.

[1] http://www.emacswiki.org/emacs/MojoSdk and http://github.com/samsonjs/mojo.el

[2] http://www.webos-internals.org/wiki/Comparison_of_Editors (temporarily down)

Perhaps vim and emacs don't do everything you want. But also, perhaps you don't know their capabilities as well as you think you do?

That said, I use vim for C, but I still use Eclipse for Java and C++/Qt.

Good keyboard navigation in an editor is valuable, and many IDEs have poor support for it. On this we can probably all agree.

But as I read it, the grandparent post was about functionality. Modern IDEs have a level of semantic awareness that generic editors like Emacs don't, at least not without a prohibitive amount of effort to implement it. As a text editor, Emacs is very powerful. As a code editor, it lacks support for even basic semantic analysis, which means such tricks as it does have are naive operations based on text matching. In a world where even entry-level IDEs have support for basic refactoring, auto-completion and code navigation, Emacs is the dinosaur that hasn't seen the asteroid yet: awesome raw power but completely unaware of the bigger picture.

Not strictly speaking true: http://cedet.sourceforge.net/semantic.shtml

Emacs may have a shallower understanding of languages than an IDE, but the breadth of languages it understands is pretty amazing.

Still, I think this raises an interesting question: is it more beneficial to choose exactly the right language for each project in isolation, or to adopt a "good enough" general purpose language that can be learned in more depth by the development team, and used together with comprehensive library support and a strong and familiar IDE?

Eclipse is a step in the right direction in terms of openness and universality. But the editing experience still sucks. And it's harder to extend and customize than it should be.

There may come a day when there's an IDE that a) has a great editing experience b) is fast, flexible, and universal, and c) offer not just crutches and marginal improvements, but radical, order-of-magnitude improvements to the way we interact with software. It's not today. But the linked research project actually has some promise.

Are you sure? I would expect that the process of physically typing in the changes you want to make takes only a fairly small amount of time, certainly much less than understanding the code that will be changed or designing the new part.

However, the typing is just mechanical grunt-work that tends to distract from other areas. If it can be automated with good refactoring tools and the like and so minimize the distraction to the developer's thought process then so much the better.

I would really like to see Yi step up at some point and solve the problem here. It's already got proper incremental parsing with a proper syntax tree. When people add advanced language-specific modes to it, it might be the first "proper" refactoring vim/emacs like text-only IDE.

Um no. But if so, then someone better start busting a lisp to get emacs to make cute little bubbles. I'd love to see that.

I can see grandma not using it, but anyone on this site ought to be able to figure out the basics in short order.

Of course, no one ever truly masters it - I'm always learning cool new things. But that's part of what makes it so great.

Unrelated but interesting out of 130 space flights 2 resulted in the destruction of the vehicle.

Nice troll though, I will give you that.

The cool things there, in my opinion, were the code navigation pieces. Those are the things I actually think work better with tabbed files.

In other news, yikes! I seem to have started an IDE vs. Text Editor flamewar. Sorry about that.

They have some great grouping features - snapping, colouring, pushing, connections with lines, naming groups.

This stuff is awesome. First time I've been this impressed by an IDE outside of Smalltalk, Self, or Symbolics, Lisp.

Since the IDE remembers all your parameter sequences and types there is also less incentive for developers of APIs to think ahead of time and plan their interface so it is consistent and easy to remember.

  foo.bar().baz().qux()

   foo >>= bar >>= baz >>= quux

foo?.bar()?.baz?.quux

What other languages have this kind of shortcut?

  $ irb
  >> def nil.method_missing *args
  >>   nil   
  >>   end 
  => nil
  >> a = nil
  => nil
  >> a.b.c.d
  => nil
  >>

Clever? Insane? Horribly un-portable and prone to breakage depending on compiler, libc, and OS versions? All of the above!

(And yes, I have seen this coding style used in multiple projects at a major corporation. It was a favorite of a coder-turned manager, which means it tended to sneak in on any project he supervised.)

Yeah, you already said it was C++.

  if (foo != null) if (bar.bar() != null) if (foo.bar().baz() != null) {
  ...
  worked = true;
  }
  if (false == worked ) {/*to do*/}

a = foo.bar() will always evaluate to true as the assignment shouldn't ever fail. Of course, in compiled languages I'm sure there will need to be a declaration of 'a' but if there is a possibility to reuse temp variables then could work.

However, if you are coding in C/C++ (and to a similar extent Java, there really is no way around it.

This could be an example of why hybrid functional, imperative, and object oriented languages are becoming popular because the programmer can pick the paradigm that most suits the problem.

Could become:

  Bar bar = foo.bar();
  if(bar == null) handleBarNull();
  else { 
     Baz baz = bar.baz();
     if(baz == null) handleBazNull();
     else { 
        //(assuming qux is a value)
        return baz.qux() * 2;
     }
  }

Say you have

    public int doubleFooBarBazQux(Foo foo) {
      return foo.bar().baz().qux() * 2;
    }

   public int doubleFooBarBazQux(Foo foo) throws NullPointerException {
     try {
        return foo.bar().baz().qux() * 2;
     }
     catch(NullPointerException e){
        throw new NullPointerException(e.getMessage());
     }
   }

Code like that is really common, and, unfortunately, so are blank 'catch' sections.

Besides, it's not like it's a primitive environment ... when I want some API discovery/learning or when I want to do some debugging (or both) ... I open up an interactive shell.

I have Textmate-like snippets setup in my Emacs, and for CRUD-stuff I bet I'm ten times more efficient than you (and adding new snippets is a piece of cake ... not to mention that we share them company wide because they are text-files in our SVN).

When wanting "rename" refactoring, commands with grep/find/sed are already hardwired in my brain.

And nothing beats editors like Vim/Emacs on pure text-editing efficiency. Also, good luck using your favorite IDE when trying out a new language ;)

So you can cringe all you want, some of us are quite happy with just text-editors.