The thing is that UNIX already has those tools--they just naturally depend on language. So, for example, Emacs has js2-mode and js2-refactor which are about as good as you can expect for JavaScript. There are also similarly capable modes for Lisp.

There are also editor-independent tools like Ensime for Scala which is basically a server that provides IDE-like tools that can be used from Emacs or Vim. Scion provides something similar for Haskell.

There are also things like CEDET for C/C++ which add very IDE-like capability to Emacs. In fact, CEDET is basically just a framework for parsing languages and using that information for things like auto-complete.

Of course, there are some languages conspicuously missing--Java and C# for example. I tried using JDEE for Java a while back and it was really bad; I've never used C# but I don't think it's well-supported either. Ironically, these are two of the languages that need an IDE the most in my experience. (And the language that needs it least--Haskell--has some support.)

So if you're doing serious Java/C# development, then you have a valid point. If you're using another language, chances are that Emacs or maybe several editors can actually support it intelligently. (Also, maybe there are options for C#/Java that I am not aware of. If so, I would appreciate being enlightened.)

Emacs != UNIX. The OP talks about awk, sed, etc.

Emacs, IMHO, is much closer to Visual Studio than to bash+vim.

I figure Emacs ⊂ Unix :)

Besides, some of the tools I listed (e.g. Scion and Ensime) are not part of Emacs but rather stand-alone IDE daemons.

Get what your saying about autocomplete, but the "avoid having to type extra characters" kind of autocomplete is very useful as well. I use it to complete things like long variable names and English text. Its main strength is that you can use it to autocomplete everything, not just the stuff your IDE is aware of.

If you set things up correctly, you can even get most IDEs to automatically fill in method signatures by making guesses based on what's currently in scope. This can save a lot of typing when it works, and even when it doesn't, it doesn't usually waste any keystrokes.

Absolutely, but can it complete column names in your database table? Or Redis commands? Or long hard-to-spell English words and sentences? :)

Vim will autocomplete based on whatever you have in the buffers. So when writing sql I sometimes open up a new buffer and paste the output of desc table.

Is someone begging you to drop your IDE for the UNIX toolchain?

IDEs have their use, Vim and Emacs have their uses, too. I'm perfectly satisfied by Vim (with omnicomplete and tags) for my JavaScript/HTML/CSS coding but I have to turn to Eclipse for AS3.

The "right" tool for the job.

Autocomplete is not tied to statically types languages. For instance, in the Python command line prompt you have autocomplete directly on the live objects.

Smart! But will it work without actually running the code? Will you be sure that the method which is available on the object now is available on each object passed to the method you're writing?

Visual Studio autocompletes Javascript by executing the Javascript and using stub objects for anything that they don't actually want to run (e.g. window, XmlHttpRequest, etc).

That sounds incredibly baroque, complicated, and fragile.

Sure it is, but so what? Would statically analyzing the code really get you any further?

Type inference would get you quite a way. Using a language that allows effective tooling would get you even farther.

Replacing Javascript with a better language has not been possible thus far. There have been many attempts, but getting every browser maker to agree on something is like herding cats.

So, when life gives you lemons, you make lemonade. We're stuck with Javascript. Personally, I think running the code while you're developing it is a brilliant way of dealing with the problem of how to do proper autocomplete on a dynamic language.

.. in other words, javascript

That kind of auto completion is very easy to do. The problem is when you have references whose creation site you can't trace statically.

To be fair, it's also probably a 90/10 situation. And whether or not it's easy to do, it's somewhat rare to see in the tools that most people use for non-static languages.

Even in Java and C#, arguably the best languages re: deep IDE integration, there are edge cases where the IDE can't know everything (reflection, for instance), but it still does the trick most of the time.

You can get some of that functionality out of ctags. I mostly use it for the navigational aspect, but I've seen it used for autocomplete too.

IDE's: When things feel only vaguely familiar, and you know just enough to be dangerous.