At Northwestern, undergraduates take a data structures course in their third quarter, after only 20 weeks of programming instruction. I teach data structures primarily as a programming course, which raises the question: What language should students program in? I was dissatisfied with most professional languages, as they present too much distracting complexity for these inexperienced students. The students were dissatisfied with Racket-like teaching languages. As a compromise, I designed Data Structures Student Language 2, which offers Python-like syntax, but with sensible semantics and a minimal library. In this talk, I will show you some of the syntax and semantics of DSSL2 and discuss how it is implemented as a Racket #lang.

slides (PDF)

Racket allows programmers to adapt the language to their needs, from defining simple syntactic abbreviations to creating entire new languages hosted within Racket. Macros are the primary source of this power. But macros have costs, too. One kind of cost is compiled code size (which indirectly also affects compilation time).

This talk is about the code size cost of macros. In particular, I’ll talk about how to measure the costs associated with macros, I’ll explain how to reduce those costs, and I’ll tell some stories about costly macros in the Racket ecosystem.

“Design by Numbers,” by John Maeda, was a formative book on learning how to program mixed with a design perspective which later influenced the creation of Processing and other languages targeting artists and designers. While the book is now out of print, working versions of the language itself have mostly disappeared. We decided to reconstruct the Design by Numbers language using Racket’s #lang facilities as a way to explore beginning languages and to allow our artist colleagues an easy way to access this language and its interesting set of features once again. In this talk, we go through the process of creating a #lang in Racket from scratch and also describe the challenges in reconstructing the semantics of the language which only became apparent after example programs did not have the same results as the text.

Racket’s more than just a batteries-included Lisp. It’s about solving problems by making languages; language-oriented programming is the name of the game. The idea has an immediate intuitive appeal. Perhaps it’s what drove you to Racket in the first place. And if it wasn’t, chances are good, if you stick around the community for a while, that you’ll find yourself thinking about languages.

But what are we talking about when we talk about “language-oriented programming”? Looking around the Racket community & among its fellow travelers, one finds that “make your own language” has a variety of senses. Although some common core ideas can be enumerated, they get expressed in different ways. At times, one wonders: are we all talking about the same thing?

To help foster the growth of language-oriented programming in general—and Racket in particular as the best environment for solving problems in that way—it’s important that we understand the diversity of meanings of “language-oriented programming” and kindred expressions. A good place to help develop that understanding is the Racket community itself and its principal drivers. Here I present the results of a survey of core Racket developers about what “make your own language” means to them.

slides (PDF)

Every year, my company teaches coding to over 5000 students in San Diego. Topics range from: robotics, game design, web design, virtual reality, Java, Python, physical computing, and Minecraft modding. Why so many topics? That’s what the market wants, so that’s what we provide. In 2018, I took on the seemingly impossible challenge of unifying all our topics under a single language of instruction. That language was Racket. This talk reports on our use of Racket and Racket-embedded DSLs to teach a broad spectrum of computing topics.

Due to the resounding success of our Racket pivot, I’m convinced that Racket is an educational power-tool for computer science education. I used to say that my mission was to teach coding to every child in the world. I can now confidently refine that mission: I want to teach Racket to every child in the world. This talk outlines the growth vision for ThoughtSTEM–a vision that will bring broad-spectrum Racket-based education beyond San Diego and into 20 more major American cities by the end of 2022. Ultimately, I want to see DrRacket on every computer in America, as a basic tool that everybody knows how to use–as familiar and useful as a web browser or a word processor. Can we make this happen? I think we can.

slides (src)

The Racket ecosystem (toolchain, libraries, documentation, etc) is surprisingly robust considering the comparatively small userbase of Racket as compared to more mainstream languages such as Java, Perl, and C++. There are some holes in what’s available, but there are some impressively esoteric items as well–things that you might not need too often, but when you need them you *really* need them.

Biomantica Inc is a bioinformatics company built entirely on Racket. This talk will cover our experience with Racket packages, documentation, etc, as it relates to our business.

slides (ODP)

Racket currently historically targets two groups: young programmers (learn by building games) and programming language theorists. We believe Racket is well positioned to meet a wide variety of people in-between these groups. Morgan will present on our use of Racket for non-programmers. Using Racket, Dr. Racket, and Scribble, we have run a series of successful workshops on “programmable publishing”. Although these were marketed to humanities students, this method can be applied to a wide variety of disciplines including the social sciences and mathematics. It can be applied outside of the university for creative writing, community outreach, and other populations with publishing needs. The common thread through these communities is users who don’t view themselves as programmers or who would like to program but don’t think they have the ability or resources to learn. Because of its accessibility, we use scribble as a gateway into basic programming skills where participants can apply their fledgling skills to a practical output that relates to their daily lives. Chris will present on Racket for the general programmer. Racket is as batteries-included as Python and is well set up to be just as general. How can we reach a general audience? What can we gain by doing so?

slides (PDF)

Digital Ricœur is a project to digitize the works of philosopher Paul Ricœur and provide analysis tools for scholars, including those with no technical background. The project is built by a small team, all of whom have “day jobs” outside of software development. Racket’s distinctive features have been a key to our success, both for our user-facing portal website and many internal tools. This talk will present our experience with Racket in practice, from the web server and cross-platform GUI toolkit to unexpected benefits of contracts and Scribble.

slides (PDF)

While writing a program, much of the time is spent working with programs that are not yet complete. Frequently, however, this incompleteness is indicated only by a comment next to a call to error. The DrRacket to-do list is a plugin for keeping track of which parts of a program are incomplete, providing a convenient list of what remains to be written. In some languages, such as Pie, the to-do list can even provide support for completing the task. The to-do list can work with any #lang, and I’ll show you how to add support for it to your language.

DrRacket is an amazing IDE. Written in Racket for Racket and more, one can write plugins in Racket to extend its functionalities. This plugin system is very general, but this comes at a cost: the development time is significant even for small functionalities, and requires to restart DrRacket at every change. For a large range of small scripts, Quickscript (formerly the Script Plugin) allows to write simple (and not so simple) scripts for DrRacket without needing to restart it and with much smaller development time, even making it possible to write short-lived scripts for single purposes. Sharing scripts written with Quickscript is as simple as sharing a code snippet.

slides (PDF)

Sinbad is a software library, intended for use in introductory programming courses, that makes it very easy to uniformly access online data sources provided in standard formats. The library provides unified support for XML, JSON, and CSV/TSV data sources, automated caching facilities (useful for having offline access to data), sampling features (for development/testing on subsets of large data sources), and binding to instances of user-defined structures. On top of all of that, a primary pedagogical goal has been to make the interface as simple and intuitive as possible for novice programmers.

Making a website accessible, usable, and attractive is important, but CSS’s complexity makes it easy for layouts to break for some users, on some browsers, at some font sizes, or on some devices. Cassius is a new project for reasoning about all possible renderings of a web page. In this talk, I’ll describe how Cassius uses the Z3 equation solver to look for mis-rendered web pages and how Racket makes it possible to implement the CSS standard accurately and concisely.

slides (Google)

Places provide a way to specify parallel and distributed computation in Racket. Using places we can set up independent services that communicate via channels. Often state machines are used in this setting to model session state, resource allocation, or service start order. However, plain state machines often suffer from the explosion of the state space as soon as multiple state variables appear in combination. Also some applications have only an infinite representation, if modeled as a state machine.

In this talk, we address these challenges by introducing pnet, a Racket library that allows to define Racket places as Petri nets. Petri nets are a class of transition systems representing state as tokens produced and consumed by transitions. We consider several examples for Petri nets as Racket places such as a worker pool and consider the possibility of driving the pnet library from a tailor-made DSL or using it to construct distributed programming languages.

slides (PDF)

Neuron is a framework for high-level network programming in Racket. Its language-oriented approach builds upon familiar abstractions like channels, ports, threads, and evaluators with support for a simple but powerful form of exploratory dataflow network programming and information flow control. In this talk, I’ll show how Neuron can be used to design composable networks of communicating processes, lift procedures and modules onto the network, and integrate with existing software infrastructure like the Web.

slides (PDF)