2. The learning curve of those languages is not bigger then the learning curve of other languages. Time time I spend with making pretty OO designs in school was way bigger then the time it took me to learn clojure and FP in general but this of course is a issue we can not solve. I just don't like it if people say something as if it is a fact.
3. Is it more convenient to do this array.select &:even? better then (filter even? array)
The later seams more intuitive to me and I didn't have to learn more syntax.
4. In Lisp not every DSL looks like Lisp.
If only it wasn't for the fact that reality and history has proven otherwise...
Most programmers went form basic (lack of alternative) to C then C++ and now Java thats a path of simularity. Most where never exposed to functional programming and now the all have a hard time to switching there OO brain off.
The only proof we have of something being easier to learn, beside anecdotal evidence ("oh, I tried it and it was easy") is statistical empirical evidence, i.e people actually learning it. Well, people are not actually learning those languages. They are learning the "other ones".
(Where by people, I mean: a significant percentage of people, > 1%. I'm sure me, you and that "professional programmer who gives a shit about Haskell" do not a significant percentage make).
Even in universities, students find functional languages difficult, and opt-out of those classes.
Wow.
> I don't appreciate that ML doesn't have a simple concept like operator overloading
ML operators are nothing more than functions. The issue of "operator overloading" comes from the type system and the simplicity of the language.
> or that in LISP every DSL still looks like LISP
You might want to read on Scheme reader macros.
> I don't like that a Smalltalk application is not portable between implementations
It's true that you don't have this issue in Ruby as the "standard" is simply the original implementation (aka there is no standard at all, and not really any competing implementation).
> or that applications are big, monolithic images of the virtual machine with everything included, even the IDE.
That definitely isn't the case. That's not the case in GNU Smalltalk, and most commercial smalltalk let you create a stripped production image which contains only the necessary code.
Check out https://github.com/rubyspec/rubyspec.
And there are plenty of competing implementations: JRuby, Rubinius, MagLev, etc.
In fact, can you mention a single language with a standard that doesn't brake compatibility with its standard?
And yet the point is moot, because compatibility between implementations is manageable for popular languages like Javascript, C++ and yes, Ruby (JRuby, Rubinius). That's not the case for Smaltalk.
<bait>When your language is already at the top of the beauty chart, why would you write a DSL that is not also beautiful?</bait>
It is really a programmer choice. Lisp programmers generally love the way Lisp looks because of the advantages awarded by those looks (check Myth #7 here: http://www.algo.be/cl/myths.htm). But you can certainly create a DSL that requires more extensive string parsing, and CL provides a lot of help towards that end, including native translations of strings to Lisp objects where your parser needs them.
I'd like to see more effort put toward creating programming environments that provide clean abstractions that span entire multi-process distributed applications.
It's just a personal preference, but I find anonymous code blocks to be a lot more elegant and intuitive than decorators + with statements + for comprehensions. I also like that classes are open, and that you can execute code inside the declaration of a class and that self is implicit ... making tasks suited for the __metaclass__ concept in Python trivial.
I also find Lisp / Haskell and ML to be really ugly ... as in, I could never look over a piece of code and understand what it is doing without learning the language first (with the learning curve being as steep as it gets).
But that's the price you pay for convenience.E.g. I don't appreciate that ML doesn't have a simple concept like operator overloading, or that in LISP every DSL still looks like LISP. I don't like that a Smalltalk application is not portable between implementations or that applications are big, monolithic images of the virtual machine with everything included, even the IDE.
It's easy to get into these mine-is-bigger-than-yours contests, especially with languages, but you know what works better than formulating half-baked opinions?
Results. It's a lot better to shut up and show me some code ;)