Racket News - Issue 40

Permalink: https://racket-news.com/2020/10/racket-news-issue-40.html

Welcome to the fortieth issue of Racket News.

Racket is in an exciting place and there was no place better to see that than in the community that joined Gather last weekend for RacketCon 2020. Due to the global pandemic, we did not manage to get together in-person but we still spent some time together discussing all things Racket and socializing in Gather’s virtual environment. This issue is packed with information including links to videos for all the talks in RacketCon. I can’t wait to see what next year will bring us - hope you are excited as I am.

Grab an espresso and enjoy!

Table of Contents

  1. What’s New?
  2. RacketCon
  3. Racket Around the Web
  4. New Releases
  5. Call to Racket!
  6. Project in the Spotlight
  7. Featured Racket Paper
  8. Upcoming Meetups

What’s New?

  • There’s a short Typed Racket Survey now online - please do take just a few minutes to fill it in.
  • Given Racket CS is built on ChezScheme, have you ever wondered if you can use Chez’s libraries in Racket CS? Wonder no more… Matthew Flatt replies.
  • Take a look at this entry to the 2020 Autumn Lisp Game Jam, written in Racket: Junior Witch High by oofoe.

RacketCon 2020

RacketCon 2020 happened last weekend on Gather Town and it was fabulously organized and led by Jay McCarthy. I had a great time meeting many of you whom I hadn’t had the opportunity to meet yet via video chat. Hope next time we get to do it in person.

The videos are now online:

Racket around the web

Do you blog about Racket? Let me know!

Edit (20.10.2020): Fix Alex’s post URL.

New Releases

If you know of library releases or maybe your own libraries and you want them to be featured, please let me know.

  • keyring(src/pkg) is a library for uniformly accessing secrets by Sam Phillips.
  • fast-sequence(src/pkg) is a library that provides efficient sequence operations that have good performance when used inside a for clause, by Anna Bolotina.
  • defensive-to-contracts(src/pkg) is a tool that converts defensive programming into equivalent contracts, by Peter Zhong.

Call to Racket!

Want to contribute to Racket? Don’t know where to start? Each RN issue I choose an easy issue to fix to get you started contributing to Racket. Come, give it a go.

This week I (happily) had my plans squashed by our last “Call to Racket” champion xxyzz. I created issue #3446 for this issue’s “Call to Racket” but before I could press “Publish” on this issue, xxyzz created PR #3447 to fix it (way to go xxyzz - thanks for the fix). Therefore I will once again issue a call to fix issue 3161. If you are interested in fixing this but need some guidance, feel free to comment on the issue page. Will you be our next Champion?

Good luck!

Project in the Spotlight

This week’s project in the spotlight is Plot by Neil Toronto, currently maintained by Alex Harsányi.

From the website:

The Plot library provides a flexible interface for producing nearly any kind of plot. It includes many common kinds of plots already, such as scatter plots, line plots, contour plots, histograms, and 3D surfaces and isosurfaces. Thanks to Racket’s excellent multiple-backend drawing library, Plot can render plots as interactive snips in DrRacket, as picts in slideshows, as PNG, PDF, PS and SVG files, or on any device context.

Featured Racket Paper

This issue’s featured paper is Corpse Reviver: Sound and Efficient Gradual Typing via Contract Verification by Cameron Moy, Phúc C. Nguyễn, Sam Tobin-Hochstadt, and David van Horn.


Gradually-typed programming languages permit the incremental addition of static types to untyped programs. To remain sound, languages insert run-time checks at the boundaries between typed and untyped code. Unfortunately, performance studies have shown that the overhead of these checks can be disastrously high, calling into question the viability of sound gradual typing. In this paper, we show that by building on existing work on soft contract verification, we can reduce or eliminate this overhead. Our key insight is that while untyped code cannot be trusted by a gradual type system, there is no need to consider only the worst case when optimizing a gradually-typed program. Instead, we statically analyze the untyped portions of a gradually-typed program to prove that almost all of the dynamic checks implied by gradual type boundaries cannot fail, and can be eliminated at compile time. Our analysis is modular, and can be applied to any portion of a program. We evaluate this approach on a dozen existing gradually-typed programs previously shown to have prohibitive performance overhead — with a median overhead of 3.5x and up to 73.6x in the worst case — and eliminate all overhead in most cases, suffering only 1.6x overhead in the worst case.

Upcoming Meetups

Do you know of any upcoming meetups I can advertise? Let me know.


Thanks to

  • Jesse Alama
  • Laurent Orseau

for their contributions to this issue.


This issue is brought to you by Paulo Matos. Any mistakes or inaccuracies are solely mine and they do not represent the views of the PLT Team, who develop Racket.

I have also tried to survey the most relevant things that happened in Racket lang recently. If you have done something awesome, wrote a blog post or seen something that I missed - my apologies. Let me know so I can rectify it in the next issue.


Have you seen something cool related Racket? Send it in and we will feature it in the next issue.