Racket Blog

Chez Scheme has an interesting compiler [1] and has also been adopted by Racket [2]. It really cool to see a little used lisp have such a great impact. [1] https://news.ycombinator.com/item?id=15156027 [2] https://blog.racket-lang.org/2020/02/racket-on-chez-status.html

So, even though Greg does not use it himself any longer, it is still in use tompower the racket blog: https://blog.racket-lang.org

Dynamic Programming and memoization are definitely related techniques, but they are emphatically _not_ the same. Memoization is a black-box approach that can be applied to a generic recursive top-down, depth-first algorithm. Dynamic Programming is about rewriting the recursive top-down algorithm in a bottom-up, breadth-first manner. Shriram Krishnamurthi explains it best: https://blog.racket-lang.org/2012/08/dynamic-programming-versus-memoiz…

> I’m still not sure what you mean by “safe.” Probably means "portable". If I'm reading it correctly, they want to be able to run Racket programs using a portability layer instead of writing a full interpreter. That would be something like using WINE vs. VirtualBox running Windows inside. > Are you worried about Racket becoming unmaintained? This is quite understandable concern, and even if it doesn't happen, having an "exit strategy" prepared is not a bad thing. > Racket itself is written on top of Chez Scheme, so does that satisfy your safety condition? Right, I forgot about it! After the rewrite/porting to CS Racket should have become easier to port to further platforms. I think much of Racket's reader and macro-expander was rewritten in pure Scheme. @MichaelBurge - take a look at the blog[1] and follow links from there[2]. Racket was ported from a custom JIT-capable implementation to Chez Scheme. It took 4-5 years, but it was finished last year. The performance is now at the same level it was before, but a lot of C code is now written in Scheme. [1] https://blog.racket-lang.org/2020/02/racket-on-chez-status.html [2] migration done post: https://blog.racket-lang.org/2021/01/racket-status.html

Essentially all projects need help. My recommendation is to read the docs of the projects you use, and wait until you find a typo or a badly written sentence. The advantage of a project you use is that you probably know the jargon, and can distinguish what is jargon and what is a typo. Note that error messages and comment in code have also many typos, so it's another source of small fixes. If you want a random project, you can try Racket. The docs are in https://github.com/racket/racket/tree/master/pkgs/racket-doc There is a friendly guide for contributions in https://blog.racket-lang.org/2017/09/tutorial-contributing-to-racket.h… but I'd wish it were more simple. I prefer to use "TortoiseGit" in Windows and "Git Cola" in Linux instead of using the git commands directly. It's much more simple and works 99% of the time. Remember that posting an issue with a report of the error is also helpful. And if you explain that you want to send it as a pull request, people may help.

Its in the footer: https://blog.racket-lang.org/

Racket is a great language. I got introduced to it through reading "How to Design Programs" (https://www.htdp.org/), which is a really beautiful introduction to programming that focuses on big-picture program design, rather than just writing code, but in a way that is accessible even to people who are new to programmers. I recently got a chance to use it for a medium-sized personal project, and it is one of the most enjoyable programming languages that I have ever used. Unfortunately, its performance, and especially the start-up time, is not that great. (At least this was true last time I checked.) As someone who hasn't been following Racket news, I'm not sure if the new Chez Scheme backend is expected to improve performance. I found this blog post (https://blog.racket-lang.org/2018/01/racket-on-chez-status.html), which seems to indicate that it is not, but that may be quite outdated. What is the goal of porting Racket to CS?

Also https://blog.racket-lang.org/

We are pleased to announce Rhombus 1.1 is now available from https://rhombus-lang.org Rhombus is easy to use and uniquely customizable. See https://blog.racket-lang.org/2026/08/rhombus-v1.1.html for the release announcement and highlights.

True. On a different tangent, I am suddenly reminded of: https://blog.racket-lang.org/2011/10/on-eval-in-dynamic-languages-gene…

It was DrScheme in the 00s. They changed the name to Racket and DrRacket in 2010. https://blog.racket-lang.org/2010/06/racket.html https://www.racket-lang.org/new-name.html

You can very easily use Racket for SICP with minimal translations, even without the `#lang sicp` package. Racket's default cons cells aren't mutable, but Racket still has them. The `#lang sicp` package mainly provides the drawing needs that SICP uses as well as defaults for the MIT Scheme used in the book. https://blog.racket-lang.org/2007/11/getting-rid-of-set-car-and-set-cd… https://docs.racket-lang.org/reference/mpairs.html

An example which comes to mind is how Racket handles tests: they're generally written in "sub-modules" of whatever they're testing, and hence they have access to "private" (AKA un-exported) definitions. https://blog.racket-lang.org/2012/06/submodules.html Framing discussions around "classes and methods" is a rather narrow-minded view, which ignores lots of potential solutions.

I've spent way more time with Racket than Common Lisp (just picked it up over the last month) and Racket just doesn't have the same development experience as Common Lisp. There's no iterative / interactive development in Racket, by design [0]. That means you have to stop-and-reload-the-world every time you make a change. [0] https://blog.racket-lang.org/2009/03/the-drscheme-repl-isnt-the-one-in…

I believe you are right. I think Matthew Flatt mentioned it in one of his more recent talks. Chez scheme didn’t become the default implementation until Racket 8.0 which released Feb 2021 so it took awhile to iron out all the bugs. They are still in the brainstorming phase and you can look at the issues in this GitHub link https://github.com/racket/rhombus-brainstorming to see what is being discussed 1. https://blog.racket-lang.org/2021/02/racket-v8-0.html

Benchmarks beg to differ: https://blog.racket-lang.org/2021/01/racket-status.html. But those may be (being the official ones) biased, so a third-party running them will be nice. Also performance wasn't the only reason. Maintainability and easier development were as well, which for language like Racket, I believe, are more important.

To add to the other reasons - the CS compiler optimizes different forms and Racket is currently optimized for it's own compiler. To give a concrete example, taken directly from the racket blog [1]: > For example, Racket BC makes dormant code relatively cheap, so Racket libraries generate a lot of code. Future Racket libraries will likely shift to take advantage of Racket CS’s cheaper function calls and dramatically cheaper continuations. One day, probably, Racket BC will no longer be a viable alternative to Racket CS for most programs. [1] https://blog.racket-lang.org/2020/02/racket-on-chez-status.html

Flatt has written elsewhere that the motivation to use Chez was not speed per se but better maintainability and portability, and that required rewriting more of the C core in Racket itself [0]. Doing so would have slowed down all of Racket considerably, but by using Chez it became possible without a big speed penalty. At first there was such a penalty because the rewritten stuff was still slower than C, but with tuning that has mostly gone away. [0] https://blog.racket-lang.org/2018/01/racket-on-chez-status.html

For those who saw this and wondered about Racket on Chez, the latest update in from February 2020: https://blog.racket-lang.org/2020/02/racket-on-chez-status.html Tl;dr: production ready, not the default, usually much faster

sometimes yes, sometimes no. https://blog.racket-lang.org/2019/01/racket-on-chez-status.html it seems it's a bit 50-50 in terms of performance gains, but the main gain, from what i understand, is the ability for the racket developers to code in racket and chez scheme now instead of c.

Racket 7.4 now comes running on chez if you so wish. Check out [1]. In there there's also the links to the whys, hows and whats of the whole effort. I've been using racket quite a lot lately, really like it. The thing I do not like about racket is the whole "racket 2" effort. Abandon S-exps? Really? To leave behind the 'popularity boundaries' of lisps? d'oh How about you drop your common USP that you share with the other lisps to become .. what, exactly.. irrelevant? Cf. your 'dialect' point: In reality, the languages are just (supposed to be) DSLs for specific (sub-)problems of your problem-space. I don't mind, at all. You just require the libraries written in that other dialect from racket and use the stuff in there, et voila. [1] https://blog.racket-lang.org/2019/08/racket-v7-4.html

https://blog.racket-lang.org/2019/01/racket-on-chez-status.html and the links at the top should provide the explanation. This paper: https://www.cs.utah.edu/plt/publications/icfp19-rddkmstz.pdf has more details. Basically, Chez is a now-open-source runtime that's very close to what Racket needs, while also being written mostly in Scheme instead of in C (as the original Racket runtime & compiler is). Building on Chez allows us to cut the amount of C by a factor of ~10 while getting a better architecture.

See http://blog.racket-lang.org/2019/01/racket-on-chez-status.html and scroll down to “Performance of Compiled Code.” That was back in January, so things may be even better now.

Maybe link to the blog post [1] instead. [1]: https://blog.racket-lang.org/2019/05/racket-v7-3.html

Racket is being ported to Chez Scheme. That might solve the batteries included problem at least at the Racket level. However, if you don't like Racket, then I don't know if it will do anything since using Racket's libraries in Chez might be too kludgy to attempt. https://blog.racket-lang.org/2019/01/racket-on-chez-status.html Since you're a Chez fan, I'll also throw in its historical overview in case you missed it. That they had Scheme on 8-bitters really tripped me out. Talented team. https://www.cs.indiana.edu/~dyb/pubs/hocs.pdf

Last year's post has some details on the organization of the Racket codebase and why some of the layers are being moved to Chez. https://blog.racket-lang.org/2018/01/racket-on-chez-status.html

Racket-on-Chez will be considerably slower than vanilla Chez - Racket semantics incur some overhead. Here are some rough benchmarks from a year ago: http://blog.racket-lang.org/2018/01/racket-on-chez-status.html#%28part…

... which is why Racket-on-Chez[0] is a really exciting development. [0]: https://blog.racket-lang.org/2018/01/racket-on-chez-status.html

The full original article, https://blog.racket-lang.org/2017/11/adding-refinement-types.html

You might be interested in http://blog.racket-lang.org/2017/04/type-tailoring.html, which argues for customised type checking.