Racket2 on a ubiquitous platform [was the case, and a proposal, for elegant syntax in #lang racket2]

[stewart mackenzie]

I want expand on and make sure Maria's point doesn't get lost in that
firestorm over at [the case, and a proposal, for elegant syntax in
#lang racket2] . Maria is bang on the money imho (her email is copied
below mine)

JVM got popular because programmers didn't need to program C.
Javascript and BEAM on the other hand became popular for entirely
different reasons: content dissemination.

BEAM is a soft-realtime vm with concurrent light-weight language
threads suitable for high up-time systems. In other words switches.
Yes, Erlang runs the Internet. This deluge of high bandwidth and
up-time communication infrastructure opened up more than enough space
for kitten photos and porn videos, then later your banking and market
trading. A new niche has opened, to be filled by the HTTP browser.

Enter Javascript, it rode the coat tails of another beast. Content
dissemination over an Erlang point-to-point communication system. We
no longer use TCP/IP to primarily connect to other machines to do
resource sharing such as printing off a document, we use the internet
to do content dissemination en mass. The HTTP browser is the gateway
to getting pictures of our children, emails from our family and
friends. Javascript rode this wave, not because of language purity,
nor blind luck, it was created to solve a problem of enabling a fat
server thin client model.

In this light, one might see it as Javascript over Erlang. But
Javascript is warty and annoying and coming to an end, a new niche is
to open and be filled. Rust is quite likely going to take this cake.
If you want to get Racket2 popular target WASM beat Rust to the finish
line. Currently only C, C++ and Rust do a good job of this.

Currently the browser enables a user to point to a domain and the
application gets reproduced on their machines executing [a game, email
client, etc]. Programmers are looking to easily get their programs
into users hands. Users buy things which pay their salaries. I know,
quite likely you're having a knee jerk at anything to do with the web.
Nasty stuff that mishmash of JS, CSS and HTML. Some good engineers *in
advantageous positions* have looked at this problem and have designed
WASM. Advantageous, I say, because their code currently ships with
every major browser, on hundreds of millions of machines right now and
is begging for someone to target it.

Opening up Racket2 to the browser, an environment such that we 1) get
a good user interface via html 2) get dissemination of our application
to users who don't need to install yet-another-vm 3) can express damn
near any syntax via honu [0] 4) create fat clients in a decentralised
environment is a clear winner.

Sadly at the moment, WASM doesn't fit well with a dynamic language
like Racket. Things like continuations in WASM and a GC would go far.
Two things that Rust doesn't need.

If you want to Racket2 popular make it easy for users to get the
programmer's responsive applications and programmers will come in
droves. Drop Chez, reimplement the Racket interpreter in Rust and
target it at WASM. Easily said that done I know. Right, let's not
pretend Honu is going to bring users by the droves, it might bring a
few, but if you're really serious about bringing in new users aplenty
this is the path to mass adoption - if you're lucky.

Lastly, what I appreciate about this mailing list is the focus on the
individual. Groups cannot be held accountable, only individuals can. I
really and truly hope we can keep focusing on each and every
individual's technical ideas and questions. For example when we first
started using Racket, Matthias Felleisen made a pull request to our
project doing a simple code formatting. That's when I knew this
mailing list and programming language was the bee's knees. Hearts and
minds won, end of story.

[0] https://groups.google.com/forum/?utm_medium=email&utm_source=footer#!msg/racket-users/HiC7z3A5O-k/t3IRVgLTCQAJ


Maria Gabriela Guimarães <maria.gabrie...@gmail.com>

Thu, Jul 18, 7:52 AM (8 days ago)
to Racket
Hello, community!

Let me tell a few words about the idea of transitioning Racket to a
traditional syntax to gain popularity: I think this idea is a fallacy.
Racket is not popular due to its s-expression syntax, because Clojure
has such a syntax, and still, it seems popular. So I don't think such
step will raise the adoption of Racket.

There is nothing new in having a traditional syntax language with
Lisp-like macros. There is one, it's Elixir. Note that I have lots of
experience writing complex macros in Elixir, and I expect writing
macros in an s-expression language to be much easier, simply because
in such a language, its notation and its AST are isomorphic, i.e.,
they share the same syntax. Let me explain this: in Elixir, sometimes,
the way to verify if a macro generates the code we want, is to see
what this code's AST looks like, which in Elixir is a kind of
s-expression (yes!), and from this, infer how to build the AST inside
the macro using the Elixir notation; this effort is totally
unnecessary in languages in which the notation and the AST are the
same thing.

In short: Clojure is a popular s-expression language on the JVM, and
Elixir is a popular Lisp-2 language on the ErlangVM, consequently, the
`Racket 2` language will contribute nothing to Racket's wide adoption.
In fact, I think it will be a strategic mistake, if popularity is all
about.

Does Racket wants to be popular in the industry? Then Racket must
focus on being a language-oriented programming ecosystem on a popular
VM, like the ErlangVM, the JVM, and the WebAssemblyVM. This means to
stop working on the RacketVM, if there's such a thing, and to start
moving Racket's language-oriented programming features into these
popular VMs. I don't think that having a kind of Elixir++ on an
unpopular VM, will make the industry adopt such a language.

For example, I would love to see Racket become a statically typed
Lisp-like language-oriented programming ecosystem on the Erlang VM. I
am sure if this ever happens, there will be hordes of programmers
jumping immediately into such ecosystem. (Ehh, I think the Shen
language is the closest thing there is, but oh my, nothing can have a
more terrible marketing strategy than that of Shen).

To conclude, I wish a great future to Racket, and will continue
following its future development. Ah, I like the Hackett idea also,
very very interesting, and promising direction, but again it needs to
target a popular VM.

Best Regards,
Mário Guimarães

[Neil Van Dyke]

A lot of interesting ideas, stewart.  For now, I'll just highlight this
one, and a few bulleted comments:

stewart mackenzie wrote on 7/25/19 3:03 PM:

> If you want to Racket2 popular make it easy for users to get the programmer's responsive applications and programmers will come in droves. Drop Chez, reimplement the Racket interpreter in Rust and target it at WASM.

* I continue to trust Matthew Flatt, et al.'s judgment and direction on
that, for the core group's goals (which I'm still fuzzy on). There've
been signs of diligence throughout.


* You mentioned a conditional, and I think re-emphasized that we all
need to have a really-super-clear shared understanding of Racket's
goals, and how people's various needs fit into that:

https://www.mail-archive.com/racket...@googlegroups.com/msg41757.html

https://www.mail-archive.com/racket...@googlegroups.com/msg41799.html

I still don't know how "popular" fits into the goals, for example.


* Regarding WASM, I started mentioning it almost 2 years ago (I've done
various kinds of Web development):

https://www.mail-archive.com/racket...@googlegroups.com/msg35803.html

https://www.mail-archive.com/racket...@googlegroups.com/msg36362.html

https://www.mail-archive.com/racket...@googlegroups.com/msg41716.html

As I said in the last message, I think WASM would almost immediately be
very valuable, but my initial gut feel is to not bet the farm on WASM
alone.  It might simplify that question for me, if I had a
really-super-clear understanding of Racket's current goals.


* I want to reiterate the importance of really-super-clear shared
understanding of at least the top-level requirements.

I've been through industry requirements elicitation and rigorous
requirements analysis before, and it's much more difficult than I
would've thought, but also much more helpful than I would've thought. 
(And when it's painful, it can be because they're getting down to things
you don't know, or getting into things some people don't want to admit
or agree to.  For example, various team members are separately excited
about 10 different possibilities and you have to choose 1-3, customer's
actual needs and priorities are very different than what anyone wants to
build or thinks they should build, you get into culling features that
the product manager and executives have already been talking about, and
various imperfect alignments between organization and individual goals,
etc.)

That's not quite the situation with Racket, but I suspect the Racket
community would still very benefit surprisingly well from merely trying
to unambiguously articulate top-level requirements.

Racket has always been guided first by the goals of the core group,
which is fine.  But as we, as a community, try to have more community
involvement, I think we need a really-super-clear articulation and
shared understanding of the top-level requirements.  Then we'll see how
that focuses all the discussion for how those top-level requirements are
accomplished.

[Atlas Atlas]

четверг, 25 июля 2019 г., 22:03:15 UTC+3 пользователь stewart mackenzie написал:

If you want to Racket2 popular make it easy for users to get the
programmer's responsive applications and programmers will come in
droves. Drop Chez, reimplement the Racket interpreter in Rust and
target it at WASM. Easily said that done I know. Right, let's not
pretend Honu is going to bring users by the droves, it might bring a
few, but if you're really serious about bringing in new users aplenty
this is the path to mass adoption - if you're lucky.

I don't share enthusiasm about web thing, because uncontrollable downloading and executing random code from internet is conceptually bad idea.

But I do share the concern regarding ChezSheme. Will it stay maintained for long time? What about ARM support? What about new architectures, like RISC-V?

What about different OS support?

[Hendrik Boom]

On Fri, Jul 26, 2019 at 03:03:02AM +0800, stewart mackenzie wrote:
>
> If you want to Racket2 popular make it easy for users to get the
> programmer's responsive applications and programmers will come in
> droves. Drop Chez, reimplement the Racket interpreter in Rust and
> target it at WASM.

I think you might find Rust's storage manaagement constraints
difficult to reconcile with Racket's garbage collection.

-- hendrik