In addition to that goal, Racket was originally created as a teaching language and continues to be used as such. Some people in the community see the odd syntax of LISP as a barrier to entry and would like to see if it would be possible to use a more Algol-like syntax for ease of learning while also preserving the properties which make it easy to extend and define new languages in.
Currently, there is already a distinction between parsing into s-exp and module-begin (i.e. all the interesting parts of your language) and this tech is already used to support languages which are based on s-exp and those which do fancier parsing such as the Datalog language.
Personally, I would rather keep Racket with s-exp and focus on cleaning up the weird stuff that is a holdover from scheme such as not having a consistent interface for comparators like there is for equal?, adding in growable arrays as part of the standard library, and not insisting upon an enormous block of end parents all on the same line (this is largely a product of the API for extending DrRacket being somewhat obtuse for indentation).
I don't consider Racket a teaching language. It was created (when it was called PLT Scheme) as a very practical and powerful implementation of Scheme, for at least 3 purposes:
* implement multiple teaching languages (for incrementally introducing language complexity as a beginner learns);
* implement an in-some-ways powerful IDE that would run on all desktop/laptop computers students might have access to;
* be a programming languages research platform.
I have an interest in education, but am not interested in using educational languages myself. I've always used Racket as a practical language, for industry production, university research, and personal techie learning/experimenting.
https://www.bloomberg.com/news/articles/2016-06-17/why-can-t...
Or perhaps it’s entirely apt.
The team even implemented Newton OS ahead of the C++ team just to prove a point, even knowing that they would be out anyway.
Search for entries from wrs and mikelevins. https://news.ycombinator.com/item?id=15106802
I suspect luck, timing and fashion have a lot to do with language adoption; perhaps more than technical merit.
Things become a little bit simpler (fewer pieces), with indentation syntax. I find that really beautiful.
As far as I can tell it can’t get any simpler than that.
https://github.com/breck7/jtree/blob/master/papers/paper3/co...
That said, I consider Haskell to be a Lisp language. But, Haskell was designed from the ground up, from ML, to be as it is.
Then Lisp (aka 'List processor') has lost its meaning.
Haskell is at its core a lazy evaluated, statically typed, purely functional programming language.
Lisp is none of that. The core of Lisp: an eager evaluated, dynamically typed, programming language supporting imperative, procedural and non-pure functional programming.
> But, Haskell was designed from the ground up, from ML, to be as it is.
Haskell was designed to have a common lazy language, instead of a dozen languages under development or in use (Miranda, Lazy ML, Clean, ...).
McCarthy about Lisp:
===
As a programming language, LISP is characterized by the following ideas:
computing with symbolic expressions rather than numbers, representation of symbolic expressions and other information by list structure in the memory of a computer, representation of information in external media mostly by multi-level lists and sometimes by S-expressions, a small set of selector and constructor operations expressed as functions, composition of functions as a tool for forming more complex functions, the use of conditional expressions for getting branching into function definitions, the recursive use of conditional expressions as a sufficient tool for building computable functions, the use of lambda-expressions for naming functions, the representation of LISP programs as LISP data, the conditional expression interpretation of Boolean connectives, the LISP function eval that serves both as a formal definition of the language and as an interpreter, and garbage collection as a means of handling the erasure problem. LISP statements are also used as a command language when LISP is used in a time-sharing environment.
===
http://jmc.stanford.edu/articles/lisp/lisp.pdf
'lambda calculus' wasn't even explicitly mentioned. But he mentions s-expressions, list structure, multi-level lists, ...
Haskell has (very!) first-class functions and is even more naturally compositional than most "classical" Lisps. It feels to me like a Lisp with static typing, laziness, and automatic currying cleverly incorporated.
Likewise Javascript. Javascript feels like a Lisp to me because it has lexical closures. It gets in my way because its syntax and many other design choices are terrible, but it still feels like it descends from lambda calculus.
I guess my point is that whether a language is a Lisp or not can't be reduced to a simple list of bullet points.
Your idea of Lisp lacks any concrete features and suddenly all languages would be Lisp: Prolog, Haskell, ML, SML, Javascript, Java, ... all of them have sone form of functions.
This then is arbitrary. Lisp is a family of languages which share concepts and code. There are a number of concepts (you call it bullet points) which make a language a member of the Lisp family in a wider sense and it may not be that all members share all concepts, but MOST and the important ones,
Haskell for example is very very different from Lisp: syntax, semantics and pragmatics. There is no way one would consider Haskell a member of Lisp languages. Lisps are not statically typed, they are not lazy, they don't use currying, they are not side effect free, etc. If a languages has all these features at its core, it's not Lisp. Claiming that it is Lisp is just creating confusion. Give a student a Lisp book (say Peter Norvig's PAIP) and a Haskell compiler: nothing runs, the concepts and architectures are different, the development style, basically everything.
Pure Functional Programming has been split from Lisp decades ago in the 70s and 80s and we have now thousands of language camps (not just two: Fortran and Lisp). The core of Lisp is still the same:
List processing, dynamically typed, a specific form of evaluation, garbage collection, s-expressions with symbols, code represented as s-expressions, built-in code transformations over s-expressions, procedures are called functions, higher-order functions, eager evaluation, optional interpretation of code in the form of s-expressions, interactive development with read-eval-print-loops, etc etc.
From there new languages families have been forked or maybe only influenced: purely functional PLs (Haskell), logic languages (Prolog), object-oriented languages (Smalltalk, Self) and many others.
Smalltalk is also not Lisp, even though it got stuff like images, GC, blocks, interactive interface, and others via Lisp influence...
Indeed, removing parents ruins the perception of Lisp languages as just another language family, and promotes Lisp into some sort of privileged position. Simultaneously, mistaking Haskell for a Lisp means mistakenly thinking that Haskell has special meaning for pairs over tuples or lists, that Lisps are statically typed or that Haskell is optionally typed, that Haskell has macros, that Haskell's juxtaposition-based application syntax is related to Lisp's parenthesis-based application syntax, and so on.
Consider example Lisp memes: "Data is code; code is data," or "all structures are lists." Compare with example ML memes: "If it compiles, it works," or "well-typed programs don't go wrong." Or even better, with Haskell memes: "Laziness leads to purity," "monads are programmable semicolons," "show me your types."
The only meme common to these communities is "lambda the ultimate", and you are ignoring decades of Lisp philosophy if you nominate this meme to carry the flag for all of Lisp. When I first read this comment tree, I wondered if everybody had forgotten about the Land of Lisp and the Republic of Haskell: http://www.lisperati.com/landoflisp/panel01.html
I consider Haskell to be an ML, and even then, it's worth remembering that lazy/non-strict MLs have different behavior from the rest of the family.
Out of curiosity: Do you think Julia is not a Lisp, or that Julia doesn’t work?
Lots of Lispers consider Javascript a (primitive) Lisp because it has lexical closures, but I think its syntax is horrible and thus (IMO) it doesn't "work."
Python is the AI language, and it's already more than large enough to survive many AI winters (plus "AI" is more powerful and useful every winter).
And it remains to be seen for how long, given C++20, Julia, ML.NET, Swift for Tensorflow and other approaches using the same underlying native libs.
The people who complain about parens are still going to ignore your language even after you remove the parens, and then the Lispers will ignore you too. See Dylan.
This debate is exasperating. It's like hearing people say "I'm not interested in that Ferrari because it has a manual transmission." The only response to which is a silent, cold stare.