ensime-server

e You can also use eclim[6] with Emacs, which integrates with Eclipse to offer rich functionality for Java. [6]: https://github.com/senny/emacs-eclim Of course, Emacs has language-aware editing for Emacs Lisp by default :). You can get similar support for most other popular dynamically typed languages as well. So yes, Emacs does support plenty of languages like that, although almost always through a plugin. Happily, with the new package manager, installing and managing plugins is now trivial.

s that make it as good as any IDE--for example, I've used TypeRex[1] for OCaml; there is also ENSIME[2] for Scala and similar tools for a bunch of other languages. [1]: http://www.typerex.org/ [2]: https://github.com/aemoncannon/ensime Just because Emacs is a great text editor does not mean it isn't a good IDE. It has some very good support for a whole bunch of languages. I'm under the impression that Java is an exception to this rule, but I really don't know--I haven't used Java in a couple of years and really hope I will never have to use it again. So, all told, I think this oft-repeated advice to use an IDE instead of a text editor like Emacs is misguided: Emacs is much more an IDE than just a text editor. Perhaps it's accurate for Vim, which I've never used (and I wouldn't be surprised if Vim support IDE features well too), but it isn't anywhere near true for Emacs.

t mix different ones by accident. This is useful because it's quite easy to have code that depends on, for example, a consistent compare function in different places on the same type. This also lets the choice of implementation be implicit at the call site, so you only have to specify the instance once rather than repeatedly in different places. I think there is also a good case for type classes not being reified as modules or dictionaries or objects or what have you: they essentially exist exclusively at the type level. That is, the instances are a property of each type, not part of a module or anything like that. This also makes the syntax for types clearer: the => acts as implication and the type class acts as a predicate on the type. In summary: type classes are more restrictive than first-class modules, but this is a good compromise. You can get the same effect with newtype, with the added bonus of having the difference reflected in the type system. I'm afraid I have not managed to make my thoughts on type classes too clear. I've been thinking about that particular design trade-off (type classes vs first-class modules) and writing this has probably helped me get my thoughts together far more than it will help any readers :P. Maybe I'll write a blog post about it--I've been meaning to start a blog for a while now... Some other thoughts: I think laziness is a good thing because you trade performance for simplicity and expressiveness. It's easier to add strictness to a lazy language than vice-versa. But I essentially use Haskell where others would use something like Python, so its relative performance is well beyond satisfactory even with plenty of space leaks :P. As far as developer tools go, Scala has Ensime [1] and Haskell has Scion [2] but I've used neither. OCaml has TypeRex [3], which I have used and is pretty cool. Assuming that Ensime and Scion are similar to TypeRex, they're certainly good enough. You never have to leave Emacs :). [1]: https://github.com/aemoncannon/ensime/ [2]: http://code.google.com/p/scion-lib/ [3]: http://typerex.org/ Coincidentally, OCaml has some of the advantages the author found in Scala while being more like Haskell. I would certainly consider at least playing around with it a bit--it's a very nice language. I still prefer Haskell, but not by too large a margin.