Welcome to the twentieth issue of Racket News.

Unusually I am writing this issue quite late in the day (in my timezone anyway) and as I look to my notes and to everything that has happened since the last issue, it feels like there are quite a few things to mention. As usual I will do my best to touch all of the important developments of the last two weeks - if I miss something let me know and if where you are, you get this a day later, my apologies.

Grab an Americano and enjoy!

Table of Contents

What’s New?

Racket around the web

Do you blog about Racket? Let me know!

New Releases

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

cover-cobertura (src/pkg) by EFanZh provides Cobertura XML output format for cover .

(src/pkg) by provides Cobertura XML output format for . diagrama (src/pkg) by Spencer Florence is a diagram drawing library for Racket.

(src/pkg) by Spencer Florence is a diagram drawing library for Racket. natural-cli (src/pkg) by Sage Gerard is a collection that helps you write non-trivial command-line interfaces (CLIs).

(src/pkg) by Sage Gerard is a collection that helps you write non-trivial command-line interfaces (CLIs). graphics-engine (src/pkg) by Eric Griffis is an accelerated graphics programming environment.

(src/pkg) by Eric Griffis is an accelerated graphics programming environment. js-voxel (src/pkg) by Eric Griffis is a general-purpose voxel programming environment.

Project in the Spotlight

This week’s project in the spotlight is Marionette, a Racket library that lets you control Firefox via the Marionette Protocol.

From the website:

Marionette lets you control the Firefox web browser via the Marionette Protocol.

Featured Racket Paper

This issue’s featured paper is Option Contracts by Christos Dimoulas, Robert Bruce Findler, and Matthias Felleisen.

Abstract:

Many languages support behavioral software contracts so that programmers can describe a component’s obligations and promises via logical assertions in its interface. The contract system monitors program execution, checks whether the assertions hold, and, if not, blames the guilty component. Pinning down the violator gets the debugging process started in the right direction. Quality contracts impose a serious run-time cost, however, and programmers therefore compromise in many ways. Some turn off contracts for deployment, but then contracts and code quickly get out of sync during maintenance. Others test contracts randomly or probabilistically. In all cases, programmers have to cope with lack of blame information when the program eventually fails. In response, we propose option contracts as an addition to the contract tool box. Our key insight is that in ordinary contract systems, server components impose their contract on client components, giving them no choice whether to trust the server’s promises or check them. With option contracts, server components may choose to tag a contract as an option and clients may choose to exercise the option or accept it, in which case they also shoulder some responsibility. We show that option contracts permit programmers to specify flexible checking policies, that their cost is reasonable, and that they satisfy a complete monitoring theorem.

An implementation of Option Contracts is available in the package option-contract-lib . The require incantation is (require racket/contract/option) .

Upcoming Meetups

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

Disclaimer

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.