Lisp Enlightenment and Emacs Frustration

But whatever the case, emacs should not be a barrier to Lisp. I might even recommend for new Lisp users: avoid emacs. First learn Lisp. Play around a bit. Most of your environment should be the REPL, and you can copy-paste from your favorite editor. You can use "(ed)" in the REPL. Go from there. Then, later on, try to get emacs to work with your Lisp. Mainly, you will want to experience the interaction, the environment with Lisp. Finally, switch back to vim when you are ready to get your real work done quickly.

I couldn't help the last line... :) Use both editors, depending on your immediate need. But learning Lisp is separate from learning emacs.

Surely, it will not be easy -- there are some problems visible even from distance. One of them are people like me who grew accustomed to Emacs' idiosyncrasies -- they're small problem. The big one are people who firmly believe that C-f,b,n,p, C-y/M-y, mainly useless functions having single-key bindings and really useful ones concealed under complicated binding, like C-x b or C-x o, or without any binding at all, like replace-string or query-replace, etc, is the way to go.

I think the poster implicitly points out something interesting---that Java and Common Lisp are both large languages that require sophisticated tools to use effectively. I'm not talking about Emacs versus Eclipse here, I mean the toolset in your brain. Money quote:

"IntelliJ makes Java programming as easy as it can possibly be. It more or less compiles your code as you type it, points out most bugs as they occur, intelligently suggests code completion to finish your words for you. I generates all the annoying repetitive code, like getters and setters and equals() methods for you. Without it, Java would be much more laborious to program in..."

So to Java users, writing annoying repetitive code is a life-saving feature of the IDE, whereas for Common Lisp it would simply be bad style.

I'm using emacs just several days.

I've used: vim, visual studio, Delphi/CBuilder IDEs, PyScripter, notepad++, PL/SQL Developer, TOAD, others.

What I found pleasant in emacs: It does not have learning curve at all.

All I need to figure is just Alt-x (M-x). Than it became fun.

I've read documentation only for cua-mode. Everything else was found through guessing and experimentation.

Of course, maybe I'm just novice and I do not know some hidden emacs dangers, one day they will pop up and bite my ass. Dunno.

Eta Someone indeed pointed this out as the first comment in 2007.

====

Java has very few original features. However, it did serve as a sort of 'feature aggregator', where it pulled in a very large pile of features from other languages and housed them all under one roof.

What I (vaguely) remember about Java from the early days as being it's (other) main advantages were:

(1) incredibly easy networking (compare sockets with C for example)

(2) applets (yes they suck(ed), but no other language had that browser adoption)

(3) it wasn't Microsoft (not such a big deal now, but back in the day Microsoft were a lot more aggressive)

(4) it was open(ish) (you could look at the library code to figure out how it was doing stuff) (compare with Visual Basic where everything either magically works or magically doesn't)

(5) Threads (compare again to semaphores)

(6) Free (as in beer)

In some cases, such as early Java, I think a feature most people don't really take into account is not what was put into the language, but what was left out. By hiding pointers behind the curtain, it made the language a lot easier. Easier to write, and easier to read. Even then it had its wrinkles, the people I know who were uber-productive in Java tended to use a small subset of the languages features.

Over the years of course feature creep has slipped in, so it now has bits of perl (regex) and bits of C++ (templates/generics). A lot more of the base code is a lot uglier than it used to be....

====

As for Lisp, I don't really buy the argument that lack of a good IDE held it back. I think the following reasons are more to the point:

A) butt ugly syntax (I'm talking about the random lengths of indents, not the ()s - to understand why this is bad, go learn you some usability)

B) greedy corporate interests (if the developer kit for Java had cost $10,000 no one would ever use it either) (early on)

C) language fracturing and speciation (there are too many 'little lisps' for any one of them to gain momentum) (later on)

D) lack of well written textbooks (compare to the veritable explosion of books for Java in its early days. Back when I was actually interested in Lisp I used to pick up books on it, and they'd invariably spend the first 2 pages showing some vague equivalency to lambda calculus and then it seemed as though they felt their teaching duty was done)

speaking of the lambdas...

E) programmers got better at naming variables and functions (having anonymous functions may be a neat party trick, but nowdays when we put on our big boy pants we like to name stuff)

F) missed the OO boat because they were too caught up in their own cleverness (early OO implementations in Lisp were butt ugly and broken (didn't do encapsulation and/or inheritance well)).

You may argue (as the author of the original article does) that currently Lisp does wonderful OO, but you have the same problem as say Java does, overcoming the slowness myth(s).

I wonder if it is possible to predict the critical junctures where the myths about a language solidify. In any case, it doesn't help to make a new lisp with more/better/faster features (in an attempt to create new myths), because that just feeds the confusion (see point C above)

edit for irony: missed a )