The latest installment of the language wars for early programming education begins as a new player enters the scene: data science. Promising to bring engaging real-world applications to tired CS curricula, data science inspires new debates over which programming language is the best starting point for beginners. As the advocates for R, Python, and Scratch sharpen their arguments, functional programming fans spot an unanticipated opportunity. Data science could be playing into their hands, if they get their pitch right. Join in as an important strategic discussion gets underway in the higher-order headquarters ...

Learn how Spritely Goblins uses Racket, object capabilities, and the classic actor model to bring a distributed programming environment that is transactional and safe in a mutually suspicious network. Learn about Goblins’ inspiration from the E programming language, see a space shooter video game taking advantage of transactionality to implement time-travel debugging, and see a small preview of social network tools that will be built on top of the system.

Whereas computers have undoubtedly empowered scientific research in many ways, they have also wrapped scientific models and methods in an opaque layer of software, making them invisible and incomprehensible to the majority of scientists. The increasing use of black-box methods is a major contributor to the much-discussed reproducibility crisis. My attempt to liberate science from software is the introduction of specification languages for scientific models and methods, which I call Digital Scientific Notations. They are meant to be used in user interfaces of scientific software as well as in technical documentation and research papers. I will illustrate this idea with Leibniz, an in-progress notation for physics and chemistry implemented in Racket as an extension to Scribble.

• Leibniz on GitHub
• An article introducing Digital Scientific Notations
• A first report on my experience with Leibniz

After a brief history of discovering the ultimate language, we will walk through building a simple web application using Racket and parts of the upcoming Axio Web Framework. Along the way, we will look at some of the features of Racket that make it such a great language for web development, some of the completed parts of the Axio Web Framework that enhance it, and a roadmap for the future.

This talk covers a functional dependency manager for Racket. The dependency manager has no side-effect on a Racket installation, which means it defines no collections. The talk includes discussion of the goals behind this approach, and a short demonstration.

Programs such as simulators and fuzz testers often use randomness to walk through a large state space in search of interesting paths or outcomes. These explorations can be made more efficient by employing heuristics that “zero-in” on paths through the state space that are more likely to lead to interesting solutions. Given one path that exhibits a desired property, it may be beneficial to generate and explore similar paths to determine if they produce similarly interesting results. When the random decisions made during this path exploration can be manipulated in such a way that they correspond to discrete structural changes in the result, we call it parametric randomness. Many programming languages, including Racket, provide only simple randomness primitives, making the implementation of parametric randomness somewhat difficult. To address this deficiency, we present Clotho: a Racket library for parametric randomness, designed to be both easy to use and flexible. Clotho supports multiple strategies for using parametric randomness in Racket applications without hassle.

A program in Racket CS is expanded and then transformed into a program in Chez Scheme to complete the compilation. The program has many run time checks due to the transformation and also the ones that were in the original Racket program or it’s expansion. We added a pass to the version of Chez Scheme used in Racket CS that does a control-flow analysis that includes the information gained with the dynamic type predicates like box? and type restricted operators like unbox. This allows the reduction of many of the redundant run time checks, adding only O(n log^2(n)) time to the compilation.

Please come with your big questions and discussion topics.

If you’re into testing, you might like the challenge of doing system (or integration) tests for a menagerie of JSON-speaking HTTP APIs, organized as distinct microservices. Sure, you can write those system tests using whatever language you want (for example, the language in which the microservices were written). But what if those tests start to look awkward and ugly? Would you make a #lang? With Racket, you certainly can, and I did! Riposte is my DSL that tries to compactly express (some of) the domain of JSON-based HTTP APIs. Here, URI Template, JSON Schema, a rough-and-ready language for specifying HTTP requests, and (of course) JSON are just some commonly occurring languages used to express concepts in this domain. In Riposte, they are available as-is (not in an encoded form, and without using S-expressions). Come find out how I made this with Racket!

Liskov, who coined the term defensive programming, advocated for programs to be written with, in her words, “a streak of suspicion”, checking the validity of inputs in every procedure. Meyer, however, stresses that these checks are often not performed systematically and can be scattered in places. Hence, they can pollute codebases, hamper performance and increase complexity. Contracts to the rescue! By lifting the defensive checks to the interface level of a component, contracts concisely articulate and enforce obligations on communicating components, ensuring that each piece of a software system does its job and can rely on the others parts to do theirs. Code written defensively remains prevalent, however, and its manual conversion to contracts is a time consuming process — but it doesn’t have to be. In this talk, I present a tool that automates the translation of legacy defensive checks in Racket programs to equivalent contracts. In particular, I will describe how the tool identifies and fixes a defensive Racket program: starting from the fully expanded form, the tool descends down the conditions looking for errors, constructs contracts from their test positions, and finally removes residual defensive code.

In the recent years, there’ve been several interesting attempts in the area of non-textual programming environments. However, the dominating idea - that programs essentially are text - seems to prevail in the heads and the tools of software developers. The purpose of this talk is to recognize the less apparent properties of text in order to pave the way to programming environments based on direct structure manipulation, rather than on serialization formats of programs.

Stephen will talk briefly about having fun with Racket, aided by a showcase of contributions to community events including the 2019 standard-fish summer picture competition, the 1st Racket GameJam, and the Quickscript competition.

Typed Racket adds a new dimension to Racket; any module in a program can be strengthened with full-power static types. Good! But powerful types rely on contracts, and these contracts can make a program run unusably slow. Not good! Shallow Typed Racket adds a new dimension to Typed Racket. Instead of deep and powerful types, Shallow offers weak types. And instead of potentially-devastating run-time overhead, shallow types charge a small fee for every line of typed code. Your code of tomorrow can mix deep and shallow types to find the best fit.

Please come with your big questions to ask Racket’s CPS.