
Suggestions for a Totally Better Programming Language - astigsen
https://academy.realm.io/posts/360-andev-2017-chet-haase-romain-guy-totally-better-programming-language/
======
flavio81
I have no time to watch a full video. Who is speaking?

On topic, my suggestion to make a better language is easy: create more tooling
and portable libraries for Common Lisp. Port some of the nicer features of
Clojure and Racket to Common Lisp and standarize them on a portable lib.

~~~
HodGreeley
This was a bit of humor delivered for entertainment at the closing of an
Android conference (360AnDev, which I highly recommend). The speakers are two
of the most well known in the Android community (Chet Haase and Romain Guy,
both from Google).

On the "easy" front, your suggestions are cool. Why do you think this hasn't
happened?

~~~
flavio81
This is a good question and deserves its own article. Much fun (sometimes
justified) has been made of the archetipical "Smug lisp hacker" or "Smug lisp
weenie" who thinks that Common Lisp is the best of the best.

On the other opposite side of the spectrum are people who claim that as long
as a language is turing-complete, all languages are "equally good" or even
"equally powerful". Which isn't really a practical advice, otherwise Assembler
would be used for prototyping web apps...

Now, what Common Lisp is, is the evolution of a language invented in 1958, a
language which has the peculiar characteristic of being able to be extended
almost without limit. This marks the difference with other late-50s languages
like COBOL and FORTRAN; to extend Cobol and Fortran (and Java, for that
matter), you need to convince the governing body of the language to add
feature X, and then they need to release a new revised standard that supports
feature X. (Example: C++14 after C++11)

While with Lisp it often can be implemented into the language using the
facilities that the language brings in, just like that. This allowed Lisp to
evolve with the state of the art in computer science, compilers and languages,
all through the 60s, 70s, 80s, and 90s. Common Lisp (ANSI standard, 1994)
wasn't really "designed"; basically, it was the standarization of things that
were already proven to be "good" and to be "the right way of doing things" all
through the past, so it has surprisingly few negatives.

One of the power features of Lisp is that it is truly a "programmable
programming language"; some would say " _the_ programmable programming
language". What this means that meta-programming is really easy in Lisp, so
easy that this is the bread&butter of a Lisp coder. In other words, you not
only write "source code", you also write "source code that generates source
code" quite often, and to a really good effect in productivity and code
readability as well (i.e. by reducing boilerplate and narrowing down the
source code to the most higher-level description of the problem.)

Another of the interesting power features are the object orientation
facilities. CL was the first object oriented language to receive the ANSI
standard. The object oriented system (CLOS) is probably still the most rich in
features and most extensible, compared to other programming languages.

Finally, the language allows many programming paradigms (OO, functional,
imperative, procedural, even logic programming, aspect oriented). Fortunately,
being able to use a multi-paradigm language is finally being recognized to be
a Good Thing.

However, to answer your question:

    
    
        Why do you think this hasn't happened?
    

There is a problem with Common Lisp; the problem is that, to be able to
leverage its intrinsic power, then you would probably be well versed in all
the programming paradigms mentioned above. Additionally, the language, being
so flexible and expressive, has many, many features and keywords and standard
functions, so it represents a large "surface area" that the beginner must walk
through in order to truly appreciate and make best use of the language.

So, Perl is "There is more than one way to do it",

Python is "There should be one-- and preferably only one --obvious way to do
it.",

...Common Lisp is "There is more than one way to do it, however there exists a
_best_ way of doing it, and you should do it that way, but that way _won 't_
be obvious if you are a beginner."

However, the language features are mostly very coherent and orthogonal, so
learning it will not be particularly _hard_ ; it will simply _take time_. To
put it in other words, it can be complex, but it is never _complicated_.

So, higher learning curve, less developers available, thus less amount of
"very nice" tooling available. However, this might change in the next years.

\-----

TL;DR: Learning curve is high to be able to take advantage of its full power.
So there aren't so many developers.

