99 percent of all articles written about lisp really just don't get it.
The reason the language is powerful (double edged sword) is simply because when you call a function in Lisp there are no commas like in most languages as part of the parameter lists, and, no requirements for quotes.
To make a lisp program in GoLang you can use a variadic function and embeed a lisp like program inside go. I'll provide a github example of such craziness. The disadvantage of writing a list processor (basically a variadic function) in any procedural language today is that you have to use commas, and often quotations, to send in the data. In lisp there are no commas as the space delimits.
Consider:
function example(a,b,c,"d")
Compared to
function example(a b c `d)
It's much cleanlier to use spaces as a delimiter if you want to fuck around with a program that can reprogram itself, because simply the quotes and commas get in your way. However, we are talking about humans... In theory, any language with a variadic function with any syntax could do pretty much anything that a Lisp program can do, so as long as.... it is interpretted at run time or it is compiled and ships with a compiler to recompile itself and you save the state and can restore it. Obviously compiled programs are tougher as it's a fixed executable that would have to be recompiled and saved to executable2.
The whole Lisp mental masturbation is really getting silly. The real power of Lisp has nothing to do with it being functional, nothing to do with it's (brackets (syntax))... The real power is simply that there are not as many requirements for characters that get in your way: commas, hefty quotations (especially ugly double quotes).
Compare this:
function example(begin HereIsADomainSpecificLanguage end)
You just created a miniature language inside a language...
Now compare that to:
function example("begin", HereIsADomainSpecificLanguage, "end")
That's much harder to mend into your own DSL because the quotes and commas get in your way. It looks like a regular function, not a DSL. It's got string parameters separated by commas and quotes, but if the language had the space as delimiter syntax then you couldn't tell whether it was a DSL or just someone playing a clever trick.
So now for the real kicker of this article: any programming language designer that offers a special function that uses space as delimiters such as
function special(only spaces required to delimit &$*# the parameters)
is on his way to making his language a mess, as now you open up the language to modifying itself even moreso than a variadic function or an abuse of an enumeration, or abuse of a set, or any other similar such hacks. In other words, the double edged sword that you creative programmers without discipline might want to try adding into your language (and, removing it immediately after) is a function or procedure that accepts parameters without delimiters/wrapping characters (quotes and others) that
"get in the way".
Also watch out for limitations, such a variadic function that can only accept 255 max parameters and no more due to some design decision...
|