
Why Emacs? - bozhidar
http://batsov.com/articles/2011/11/19/why-emacs/
======
aufreak3
> A very trivial example is the fact that most IDEs don’t even have
> keybindings optimized for touch typing - they require you to move your hands
> often from the home row (such a waste) and have mouse-centric UIs.

what? ... and Emacs has optimized key bindings for touch typing? C-x C-c!

Personal notes here - I know emacs-vs-vim is war, but I'm interested in the
cognitive aspects of why one works for some people and why another works for
others.

My own preference - vim - is driven by memorability of commands. Though I used
to use emacs for a long time, remembering commands was a problem for me.

When I tried vim, I found many of the commands I need frequently to be
memorable because they are _compositional_.

Here is what I mean - if I learn the concepts "delete = d", "change = c",
"copy(yank) = y", "in = i" and "around = a", I can construct "delete around ("
= "da(", "yank block" = "yank around {" = "ya{", "change array contents" =
"change inside [" = "ci[" and so on.

So do long time emacs users just remember the keystrokes or have some kind of
logic like that for them?

edit: I _know_ emacs is much more than that, but my usability question is
purely about the keyboard interface.

~~~
rdtsc
> what? ... and Emacs has optimized key bindings for touch typing? C-x C-c!

I can type C-x C-c faster than switching to a new "mode" or moving the mouse
pointer anywhere.

As for memorability of commands, I really remember them using my finger motor
memory. If you are stopping to think for what the command is before using,
might as well start moving the mouse.

The question is then, how does one get to that point? And that what you are
pointing out I guess, when learning, it is hard to remember. The trick though
is to do it, step by step.

If you just know how to save and quit the program you can use the editor in a
very basic way. Use arrows, and type. Then you can learn commands as you go
along.

~~~
jamesbritt
_If you are stopping to think for what the command is before using, might as
well start moving the mouse._

No, because over time you will pause less often, and for less time, until it
becomes automatic.

~~~
rdtsc
That is true initially, and one has to go through that process. But eventually
it reaches a point when it is automatic and then the ease of memorizing the
command doesn't matter (provided the person stuck with it and didn't decide it
was too much of a pain to learn).

~~~
jasomill
This seems to depend on the nature of the command --- "move to the word I'm
looking at" is often faster with a pointing device (though I haven't regularly
used a _mouse_ in years, I use a trackpad on the left and a digitizer tablet
on the right). For most other text-related commands one uses often, I'd agree
(though I've never used a stopwatch to test it, and "the easiest person to
fool" is often one's self in these sorts of "efficiency" contests ---
perception can mislead).

------
SingAlong
Did anyone else try "M-x butterfly" after reading the comic strip in the blog
post? I just tried it out of curiosity and it seems like an easter egg :D

1.) M-x butterfly

2.) The mini-buffer asks "Do you really want to unleash the powers of the
butterfly". I entered "yes".

3.) A new buffer opens up and then there's this text-based animation with the
text "Amazing physics going on..."

4.) The mini-buffer says "Successfully flipped one bit!"

~~~
jerrya
m-x find-function butterfly

    
    
      (defun butterfly ()
        "Use butterflies to flip the desired bit on the drive platter.
      Open hands and let the delicate wings flap once.  The disturbance
      ripples outward, changing the flow of the eddy currents in the
      upper atmosphere.  These cause momentary pockets of higher-pressure
      air to form, which act as lenses that deflect incoming cosmic rays,
      focusing them to strike the drive platter and flip the desired bit.
      You can type `M-x butterfly C-M-c' to run it.  This is a permuted
      variation of `C-x M-c M-butterfly' from url `http://xkcd.com/378/'."
        (interactive)
        (if (yes-or-no-p "Do you really want to unleash the powers of the butterfly? ")
            (progn
              (switch-to-buffer (get-buffer-create "*butterfly*"))
              (erase-buffer)
              (sit-for 0)
              (animate-string "Amazing physics going on..."
                              (/ (window-height) 2) (- (/ (window-width) 2) 12))
              (sit-for (* 5 (/ (abs (random)) (float most-positive-fixnum))))
              (message "Successfully flipped one bit!"))
          (message "Well, then go to xkcd.com!")
          (browse-url "http://xkcd.com/378/")))

------
nosignal
I've recently (~3 months) started using emacs "full-time" for org-mode, text
notetaking, Python, and Octave.

Here is a (small) list of things I'm sure emacs can do:

\- Integrate with git;

\- Run my Python and/or Octave code inside emacs;

\- Perform autocomplete on my Python/Octave code;

\- Become my blog publishing platform using a combination of the above
features;

\- Replace my email, twitter & RSS clients;

\- Read and post to HN from within emacs

Here is a list of how many of those things I, personally, can actually do
using emacs:

-None of them

I love it for a text editor, I love the keybindings and commands, I love the
theory of how extensible it is. But by god it's a nightmare to set up and
configure. For all the "guides to emacs" there are out there, it would still
take me about 2 or 3 days to get it running like the well-oiled machine I'd
like it to be.

I'm sticking with it, but when I'm learning Octave, to learn about Machine
Learning, to get better at programming — having to stop to learn how to use my
text editor is just one step too far.

One day work will settle down and I'll have more time to stuff about getting
emacs to do exactly what I want; but for now I feel like I'm using IBM's
Watson to help me beat Words With Friends.

~~~
timf
I don't think a lot of those things are worth learning. I would never consider
using git from anything other than the shell or email from anything but my
favorite client. It's all personal, of course.

> _Perform autocomplete on my Python/Octave code_

.. except for auto-completion, who doesn't like that? :-/

Try the 'dabbrev-expand' command for auto-complete in _any_ mode (naive match
on other words in the buffer): M-/

Then check out 'C-h a expand' and 'C-h a complete' (apropos searches for
commands related to code completion).

~~~
rcthompson
Don't dismiss the value of Git integration in your editor until you've tried
Magit in Emacs. I hardly ever need to run git at the command line anymore. I
particularly like how easy it is to stage individual hunks in Magit.

~~~
fakeempire
Magit is probably my favorite piece of software. It's truly epic. It alone
would keep me from ever switching to something else. Although emacs has plenty
of other things to keep me around.

------
mixmax
The power of emacs is also it's biggest flaw - it's a tremendously powerful
piece of software but it's hard to master.

I think it's a matter of discoverability.

A simple program such as Microsoft paint delivers a nice inital experience -
my mom will be drawing moustaches on her pictures in no time. The reason for
this is that it has great discoverability: Click on the little pencil and
start drawing. Nothing to know, nothing to remember, just start using the
program. This, of course is also it's biggest drawback - as the complexity and
possibilities of a program increase it becomes increasingly difficult to
create a simple GUI.

If you move up to something like photoshop you start to reach the limit of
what a graphical user interface can deliver. It's hard for a beginner to just
sit down and start. There are masks, layers, palettes, and all sorts of other
things to master before you can really use the program the way it's meant to.
There's still discoverability - you can actually learn photoshop without a
manual, just by clicking around. But it comes at a cost: A lot of options are
hidden behind two, three or sometimes four mouseclicks. So you have a program
that's hard for a beginner, but not streamlined enough for an expert.

Emacs is at the other end of the scale. It has basically ditched the crutches
that are the graphical user interface, which makes it a great program for
experienced users that know exactly what they want to do and how to do it. But
it has no discoverability. If you don't know how to perform an action emacs
won't give you any clues(1), and it won't tell you what it can or can't do. An
often heard remark in regards to emacs is _"Wow I didn't even know you could
do that_ ".

(1) Yes I know there are MAN pages, manuals, etc. but they don't count. I
often get better results from a simple Google search.

~~~
kiba
_The power of emacs is also it's biggest flaw - it's a tremendously powerful
piece of software but it's hard to master._

I think that's wrong. It more having to do with emacs having old arcane UI
convention that doesn't make sense to a modern user.

Where is my copy and paste? It's not C-c C-p? Save is C-x C-s? WTF?

~~~
espeed
Emacs is about muscle memory -- after a while, it just flows.

~~~
rdtsc
Yes. If you stop to think about what the key-binding is for the command, you
are not using emacs efficiently.

Interestingly I would not even be able now to teach someone what the commands
are without having an editor open, as I don't really remember them, only my
fingers remember the sequence. It is like my brain has built a macro for the
command and sent the actual code to the fingers, so I don't have to think
about it.

~~~
kamaal
How is this any different, like using any tool used by any profession by a
professional frequently.

Programmers, Musicians, Carpenters, Chef's, Drivers and almost everyone in
those lines use their tools frequently enough such that their usage is
committed to muscle memory and not the usual think-act-think cycle.

That's also because most problems are matched to solution patterns. You might
have seen this while working with the programming language you have mastered.
If there is syntax error, you generally don't read the entire error message.
You just ideally read the template and the 'fill-ups' in the template and the
line number. You go straight without bothering much and fix it.

Same with an editor. There are some things that you do so frequently, its
actually better and efficient if the editor enables muscle-memory use cases
than Apple product's kinda UI design.

Its precisely this 'problems matched to solution patterns' thing that will
some day enable us to do drag and drop programming.

There will ready templates for each problem each of which will match a
solution pattern. We will just parameterize the templates. To an extent this
is already there auto-complete, macros, template driven programming etc. But
in future we may see full scale stuff like this.

~~~
rdtsc
> How is this any different, like using any tool used by any profession by a
> professional frequently.

It is not. However since it is an editor, it can be a tool used by a number of
professions -- a writer or a programmer.

What it improves is text editing capabilities. How does it improve them? It
help you keep your hands on the home row. Not saying that vi doesn't do that,
it does too. So they can both work. One can argue perhaps that emacs' key
combinations are harder to memorize but eventually they are easier encoded
into muscle memory.

> To an extent this is already there auto-complete, macros, template driven
> programming etc. But in future we may see full scale stuff like this.

Interesting point. I think there is a larger discussion point in there. In
general that hasn't happened and wizards, macros and templates still haven't
replaced programmers. Business, non-programmer, programming languages, built
from drag-and-drop components have been dreamed about since COBOL. And it is
funny, but it still hasn't happened. The idea was that instead of hiring
programmers, managers would just encode business rules in an easy language or
environment and bam! mix in some AI and they are done.

~~~
kamaal
Not exactly. If all the user wants is a editor. Which generally acts as a
cache for temporary text a general user wants to use somewhere else. There is
always notepad or wordpad. There is also a word processor called Microsoft
Word. Which generally does more than sufficient job. There are sufficient
enough alternatives. Emacs can't become notepad just to become usable to
general users. Emacs's design case is for programmers who need to do a lot
text lifting, execute repeated patterns of complex text editing.

Keeping all this in mind Emacs is designed, to facilitate use of macros and
alikes. There are also key bindings to enable short cuts to do that sort of
automation quickly. Also there is a huge repository of what the community
considers 'common pattern of solutions' to most problems developers face while
editing code. Emacs is mean't to provide large gains in productivity while
coding for long hours. Notepad is designed for a few minutes of use by a user.
Vim is optimized on similar line of Emacs, but in a different usability case,
which is also awesome and serves some users pretty well.

Also we already have drag and drop programming to a very large extent these
days. Most people working on SAP, and package based solution don't see code in
years. But they actually do a lot of programming. In most mega corporations
there are business units, where there are consultants, who do a lot of domain
logic coding by mere button clicks on GUI. You will surprised how many large
number of people are actually with that sort of a thing these days.

Not to mention armies of Java programmers. If auto complete weren't to be
there how many Python and Java programmers and their supply in the industry
will actually scale? Given the verbosity and configuration hell I doubt even
half of that would be possible. Even the mere existence of those programmers
is dependent on the existence of eclipse. Remove away eclipse today, and you
will see the supply of Java programmers will fall by 90%. Even those 10%
available programmers will suffer a massive decline in productivity.

We are already in the drag and drop era. We are just not realizing it. Since
we are doing it in different ways.

~~~
dextorious
"""Not to mention armies of Java programmers. If auto complete weren't to be
there how many Python and Java programmers and their supply in the industry
will actually scale?"""

I don't think I ever used autocomplete with Python. And I don't know many who
do, either. You really believe many Python users use something like the
Eclipse python mode?

Except for the "tokens in the same file" autocomplete that Vim and such
editors offer.

~~~
Erwin
After 10 years in Emacs I've switched to PyCharm (for about 100 EUR). Its
autocompletion feature are quite decent (aided by specifying types in
docstrings but otherwise it does whole-project type deduction) and I use them
frequently.

It has many time saving features -- like real time "pyflakes" like warning,
automatic import management (when I type time.strptime it warns me about time
being undefined -- would I like to import the time module?).

Only downside is that it can get sluggish in large file on this 5-year old
processor.

------
kiba
20 years old like me are using emacs these day. It's not for old people
anymore. I bet there are people in the world who are two decade more than my
age and never touch vim, or emacs.

~~~
__david__
Not for old people anymore? Why when I was your age.... Well, I was using
emacs. Seriously, 20 year olds have always been using emacs. It's just that
suddenly 15 years go by and you're not 20 any more (but your .emacs file will
be cleaner).

------
maximilian
In the article he links to "Emacs Prelude". From its README:

 _No arrow navigation in editor buffers

This is not a bug - it's a feature! I firmly believe that the one true way to
use Emacs is by using it the way it was intended to be used (as far as
navigation is concerned at least). That's why I've disabled all movement
commands with arrows - to prevent you from being tempted to use them._

I don't use my arrow keys that much, but do any others see this as a useful
feature? How do you typically navigate around code in Emacs?

~~~
calibraxis
Mainly, I use my arrow keys for M-x tetris. ;)

To navigate, I typically use incremental search (C-s or C-r). Because moving
up line-by-line is a slow linear process which gets annoying if you're not a
couple lines away from the target.

You can also use the mouse, which is a very direct way of getting where you
want to go.

There's also page up/down. (If you don't want to move your hands, that's C-v
and M-v.) And for moving the screen (without moving the cursor), there's a
quick C-l. If you want to go to the very ends of the buffer, there's M-< and
M->.

Then there's linguistic motion, because you're often thinking in terms of
moving in units of text. So, M-f if forward-word; M-} is forward-paragraph.

Then there's navigating units of code. Which is like moving in units of text,
but you press control too. Like C-M-f is forward-sexp, which pushes you
forward a code unit. (Like a string or variable name.) C-M-a is beginning-of-
defun, which gets you to the start of the function/method/whatever you're in.

------
jphackworth
One feature of Emacs that I wish IDEs would or could adopt is macros. It
really enables a larger set of refactorings when you can repeat any text
transformation. You really need non-popup find-this-string, though.

~~~
cturner

        One feature of Emacs that I wish IDEs would or could
        adopt is macros
    

I think you'll need to have a reflective language as your foundation to do
this as well as emacs. It doesn't have to be a lisp - io language has this
property as well. But otherwise the IDE developers need to consciously build
and expose functionality. Despite this amount of work, users will keep running
into things they hadn't thought of and which won't be accessible (unless you
build a plugin - a similar concept).

~~~
yoklov
I suspect he means keyboard macros, as opposed to macros defined in emacs lisp
using forms like defmacro. Keyboard macros allow you to record an arbitrary
sequence of actions, whereas lisp macros allow you to perform arbitrary
transformations on your code. I could be wrong though.

Still, keyboard macros could be amazingly useful in an IDE setting.

------
keeptrying
I use emacs. But arguing between Vim Emacs and Textmate is a perfect waste of
time. Get back to work.

~~~
chromejs10
He's not arguing which is best at all. He just talks about why he loves Emacs
so much. It's a nice article that may make some non-emacs users look into
using it.

~~~
aiscott
I _want_ to use emacs. I really do, mainly because of its lisp integration.
Partly because I don't like being "locked" into vim. This article does make me
want to give it a shot again.

But it is so painful to try to switch. It's a heavy cognitive load to do even
simple things like navigation. The best way I can explain what it is like is
to reference the frustration of trying to switch from QWERTY to Dvorak.

It is incredibly frustrating to go from 60 WPM to 10 WPM. It burns so much
brain energy on such a critical and fundamental task. There may be a great
payout if you are successful, but it's a big hurdle to get over.

There are some things that emacs does better than vim can, that I do want to
switch. I'm just starting to doubt my reserves are sufficient for that task
and doing other productive work at the same time.

Edit: completing some thoughts

~~~
ecyrb
> But it is so painful to try to switch. It's a heavy cognitive load to do
> even simple things like navigation.

You might be interested in viper mode [1], or another one of the VI emulation
modes for emacs.

[1] <http://www.emacswiki.org/emacs/ViperMode>

~~~
aiscott
Yes, I have tried viper mode, and it's a good effort. But it can only handle
the basics, or at least when I tried it was just the basics. I have a ton of
vim scripts customizing vim, adding features, etc., that just don't work with
viper mode.

Part of me thinks that if I go over to emacs, I ought to go with the 'native'
experience of it.

I appreciate the reply; and others may find Viper mode very useful.

~~~
ecyrb
vimpulse is an extension to viper and gives you (for example) visual mode
(copy blocks using 'v').

<http://www.emacswiki.org/emacs/Vimpulse>

------
greggman
I'm going to stick out like a dork I suppose but I prefer slickedit. It gives
me all the stuff claimed as great for emacs AND all the stuff claimed great
for IDEs. The only thing it doesn't give me is vims smallness but since I
rarely exit the editor that doesn't effect my workflow.

~~~
tseabrooks
I'm a huge fan of slickedit. I've switched to OS X in the last couple years
and the crappiness of slickedit on OS X has me looking for a new editor.

~~~
greggman
They are privately testing the beta testing the native OSX version of
Slickedit right now. They expect to have a public beta within a couple of
weeks.

------
agentgt
I am a long time Emacs users but now I shamelessly admit I am an Eclipse user.

Eclipse handles plugins really well. What I loath about Emacs is its plugin
management. It is a PITA to download new plugins or update existing ones.

Also Eclipse generally understands the programming language your working on.
The whole you have to use your mouse in Eclipse is total BS. In a simple
keystroke I can navigate the type hierarchy of a class and or the call
hierarchy of a method.... not to mention auto-completion.

For Scala, Java, Javascript, and XML I use Eclipse. For Python I use Emacs
because its still the best editor for it.

If your using a JVM language give Eclipse a try. I'm glad I did.

IMHO IDE vs Emacs is becoming so Déjà vu of Emacs vs Vim.

~~~
pivo
For what it's worth, Emacs 24 has built in package management. It's arguably
easier than using eclipse's package management.

------
k_bx
Also I noticed only recently that emacs32-nox is really-really lightweight and
starts immediately, so I am happy to install/run it on my servers.

~~~
hollerith
I think you mean emacs23-nox

~~~
k_bx
Of course :)

------
morazow
I have started using emacs recently. Before I was using vim (approximately
4years), and one of the things I liked in emacs is there is no editing and
command mode, you don't have to press ESC and goto the end of program in emacs
and then enter to edit mode, for instance. However, I think it will take time
and patience to master emacs.

------
X-Istence
When the author starts going on about IRC and email within emacs the first
thing that came to mind was an old joke:

"Emacs has everything, email, chat, and even a web browser, hopefully next
year they include a text editor"

or

"Emacs, for when you want to do anything but edit text"

Now I will readily admit that I use Vim for my day to day work and have not
spend any significant time in emacs, but I do find the many control commands
jarring and difficult to remember.

My boss is a big emacs guy, and whenever I help him with code or he helps me
with code we make fun of each others editing environments :P

I hope to eventually have the time to learn emacs to its fullest and
understand it. Being able to use a variety of different editors won't hurt.

------
rayiner
I love Emacs. Have used it for years. Which makes it frustrating that the GUI
sucks so hard. I program on a laptop which means that reaching for the mouse
is far less expensive then it is with a keyboard+mouse setup. Sublime Text
supports this beautifully, by offering pretty comprehensive keyboard-ability
while not neglecting mouse-ability. Emacs just falls down hard on this front.

Not to mention that on OS X it does pretty much everything against the basic
conventions of the OS.

------
jaequery
people think emacs users use emacs for it's sheer power but i think that is
the wrong perception to have (and promote).

the sheer power is in it's key bindings. it lets you literally take full
control of texts with pin-point precisions just like a surgeon does with his
tools. the speed and efficiency of it is just un-matched by any text editors
out there. i've seen some power vi/vim users get close to speed but still can
not rival against a power emacs users. long live emacs.

~~~
rbanffy
I like being able to easily write my own functionality. It would take weeks to
do on Eclipse what I can do in a leisurely afternoon on Emacs.

Archaic a dialect of Lisp as it is, Emacs Lisp makes Java look like something
out of the 50's.

------
georgieporgie
In my limited experimentation with Emacs, trying to get started with
Lisp/Scheme, it seems like a bit of an ergonomic nightmare. That may be
affected by my Dvorak layout and Kinesis keyboard, perhaps Emacs is the one
Kryptonite of this combination...

------
diamondhead
Emacs is a platform, others are only editors.

------
billpatrianakos
We get it! Emacs is god. Or Vim is god. Whatever. Why do we keep having to be
subjected to Emacs/Vi love letters on the front page of HN? Then someone says
"but Emacs can't do this!" then the other guy says "well vi cant do that!"
then we talk about key bindings and it becomes the same post with the same
comments and then everyone downvoteed the guy who called it out. Next story!

~~~
dextorious
"""Why do we keep having to be subjected to Emacs/Vi love letters on the front
page of HN? """

Because we like reading them, stupid. This is a community driven site.

------
derpsaidderp
I think emacs is probably one of the biggest mistakes to ever happen to
computer science.

First, let's remember that emacs is not powerful in and of itself. It requires
mastery to understand the potential and power that lies in it. The inclusion
of emacs lisp is amazing, but seriously? Have you programmed a separate
application in emacs lisp? You haven't? What? You used Scheme or Common Lisp
instead? Than why the fuck are you defending emacs lisp?

And that is the biggest flaw. The flaw no one likes to talk about. How many
people have picked up emacs and quit? I certainly have. Numerous times. How
big do you think the population of people who have tried emacs is to the
number of current users? Seriously, in terms of a conversion rate, it's
absolutely terrible. And you think that's a good thing? Don't give me that
bullshit about how only "smart" people will put the effort in. It isn't about
fucking effort. It's about giving people the confidence to learn more about
your software. And emacs almost definitely fails there.

And that's the whole fucking point of computer science. It's not writing the
"greatest" programs. It's sharing. Sharing techniques, skills, libraries and
ideas. And emacs is an artificial barrier. And worse than that, the most elite
people in CS continue to protect it and cannot comprehend that their elitism
is to the detriment to CS as a whole. It's complicated, arbitrary and designed
in a terrible manner. I don't care if it makes sense to you. What matters is
that you should be able to easily defend any design decision. And you can't.

We need more people to start programming. We need better editors. Why is it
that CS has some of the oldest, most decrepit tools with the most adamant
defenders? Why?

Seriously, we deal with fucking computers all day. The most arbitrary
representation of knowledge possible. And all people do is whine about how
things are "good enough" or "no, someone made this decision a long time ago,
and now a lot of people make the same choice, so don't be stupid and choose
that."

The number of new computer languages being invented is almost fucking SLOWING
down. WTF? Computer science is about the drive to find better ways to express
and share knowledge, and that means trying new things. Usually, they will
suck. But jesus, we have to keep trying. And whatever we do, we have to help
a). more people try programming, and stick to it b). support people following
their own loony ideas.

I mean seriously, it's fucking sad how slow shit happens. Common lisp, one of
the more powerful languages ever invented, got a wonderful tool called
quicklisp last year. 15 FUCKING YEARS AFTER CPAN CAME OUT. Why the fuck is
shit so fucked up, I mean jesus, it's fucking inexcusable. Our descendants are
going to mock us to our faces til we fucking hara-kiri.

~~~
kabdib
I am very, very good with Emacs. There are no other editing platforms that
have its power and convenience. If I didn't have it, I would be forced to
invent it. (I did in fact do a small Emacs implementation for a microcomputer,
back in the 80s. It was fun).

My customizations? Nada. I rarely bother. My ".emacs" file is about 20 lines
long, mostly turning stuff off that I don't care for.

If you whip up a tool that is /better/ at working with million-line-plus
projects in C/C++, let me know. You seem to be on fire about it.

[I use Visual Studio for C#, and for its debugger. But the heavy lifting is
still done in Emacs]

~~~
derpsaidderp
That's the thing though. You're comment about the debugger? That gives it all
away.

My comment isn't just about emacs. It's about all the tools we use. There is
no real incentive to fix them. To make them work together. We wait for other
people to make it. We all wait.

I can't whip up a tool better than emacs. I can't even imagine it. But, that
doesn't mean it can't exist. And you're attitude towards my complaints? That's
probably putting off your coworker, someone who could invent it.

~~~
dextorious
There are better complaints than yours. I can't whip up some. I can't even
imagine them. But, that doesn't mean they can't exist.

This is your bizarro logic in action.

"Something better surely exists".

Well, no shit Sherlock.

Either 1) do something, 2) propose something better than someone else can
implement, or 3) shut up.

Your comments are idiotic. Who told you that there aren't real people out
there trying to implement something better than Emacs?

XCode 4's use of an _actual_ parser's AST for code completion, refactoring and
syntax highlighting comes to mind. Or Visual Studio's overall integration. Or
even Eclipse meta-platform extensibility. Subethaedit's concurrent editing
ability. And a lot more stuff, besides...

"Where are my robot ponies and flying-cars, they just have to be" is idiotic.

