> Arc was implemented on top of Racket
Originally on MzScheme, then later PLT Scheme. It was ported to Racket by the great kogir, IIRC.
I think MzScheme is just the core (non-GUI) part of PLT Scheme, which was renamed to Racket.
Also, I believe pg started implementing Arc on Scheme48 based on mailing list activity at the time. I've always been curious about the switch to PLT!
That might've been more a reflection on PLT than on Scheme48 (which also had some really smart people on it).
As some point, when I was writing a lot of basic ecosystem code that I tested on many Scheme implementations, PLT Scheme (including MzScheme, DrScheme, and a few other big pieces), by Matthias Felleisen and grad students at Rice, appeared to be getting more resources and making more progress than most.
So I moved to be PLT-first rather than portable-Scheme-first, and a bunch of other people did, too.
After Matthias moved to Northeastern, and students graduated on to their own well-deserved professorships and other roles, some of them continued to contribute to what was soon called Racket (rather than PLT Scheme). With Matthew Flatt still doing highly-skilled and highly-productive systems programming on the core.
Eventually, no matter how good their intentions and how solid their platform for production work, the research-programs-first mindset of Racket started to be a barrier to commercial uptake. They should've brought in at least one of the prolific non-professor Racketeers into the hooded circle of elders a lot sooner, and listened to that person.
One of the weaknesses of Racket for some purposes was lack of easy multi-core. The Racket "Places" concept (implementation?) didn't really solve it. You can work around it creatively, as I did for important production (e.g., the familiar Web interview load-balancing across application servers, and also offloading some tasks to distinct host processes on the same server), but using host multi-core more easily is much nicer.
As a language, I've used both Racket and CL professionally, and I prefer a certain style of Racket. But CL also has more than its share of top programmers, and CL also has some very powerful and solid tools, including strengths over Racket.
Are we iterating over all lisp implementations ? A strange variant of the ship of Theseus
Next up, the end goal: Emacs Lisp.
Yes and dynamically scoped.
Elisp supports static scoping now. Also, native-code compilation. I haven't tried benchmarking it against SBCL, though, and I would be surprised if it approached SBCL's performance.
Oh yes! I was joking that if we were going to port Arc to Emacs Lisp, I would want it to be the classic, dynamically scoped version.
I don't mean that, of course. But there's a reason for the joke. When I did extensive work in Emacs Lisp (before they added lexical scope) I came to appreciate (1) how amazing a domain-specific language it is, for the domain of a programmable text editor—it's really one of the ultimate classics of a domain language; and (2) how everything being dynamically scoped was somehow closely allied with this domain. It made Elisp less useful as a general purpose language (lexical scope is a good thing!) but arguably more useful for making and extending a programmable text editor.
That seems plausible. But I wonder how far you could get in a lexically scoped language using temporary assignments to variables that get automatically undone when exiting a scope, the way dynamic scope is usually implemented with shallow binding. Other domains where you often want such temporary assignments include floating-point math (execute this calculation with the rounding mode temporarily set to "upward") and graphics (execute this drawing with the current transformation matrix temporarily set to foo and the current color temporarily set to bar).
yeah that would be a fun thing to do, even though yeah SBCL compiled code will probably be an order of magnitude faster
Aren't MzScheme, PLT Scheme, and Racket the same thing?
Yes, but for me each name denotes the thing as it was when it was called that.
(This conversation has turned unexpectedly ontological!)
I always wonder whether it's really the same conversation anymore when that happens.
Welcome to HN :)
this made me crack, you _do_ know who you welcomed to HN, do you? and I saw the smiley but I have to know if it was intentional or accidental:-)
They were all based on MzScheme, yes. But nowadays Racket runs on the fastest scheme, chez.
HN runs now on SBCL, which is much faster and also multi-threaded.