Slides

Racket is more than a programming language. It is a programming language for making new languages. In fact, it is a programming language for making languages for making movies. Video is a language made from the sweat and parenthesis provided by the Racket ecosystem. It integrates into Racket from concept to final rendering. Come for the video demos, stay for the language tower.

The universe library of Dr Racket is interesting in its use of state and the contracts of the functions of the main loop (big-bang) are particularily apropos in the field of robotics. In this talk we will present a layered approach for teaching high school students about Kalman filtering using the universe teachpack. The approach develops the functions for one-dimensional movement both for exact motion and inexact motion. One-dimensional particle systems are introduced and then the model is extended for the full Kalman filtering algorithms using matrices. In the process, students learn how to develop physical models for their objects using standard trignometric and algebraic ideas. Models are extended to include two-dimensional models.

You can use the functional programming techniques that you’re familiar with from Racket to write mathematical proofs. An upcoming book in the spirit of “The Little Schemer” will demonstrate how to do this, and tell you how to write your own proof system in Racket. This talk is a little taste of #lang pie, where programming and proving meet.

With the rise in adoption and decrease in price of single-board computers, high-level languages like Racket can find good use in embedded scenarios which are not real-time. Features of the language support all stages of development with few downsides.

Slides

What can we gain by looking at deep learning through the lens of functional programming? This question has gained attention over the last few years as increasingly complex neural network architectures are developed. I recently started developing a framework for specifying and training neural networks in Racket. In this talk, I’ll give a report on the project and invite discussion on future work.

Slides

Testing in Racket can be downright joyful. Submodules and RackUnit make simple unit tests easy and quick to write, even in an unfamiliar codebase. But Racket’s testing story has more than a few holes when it comes to more complex tests. This talk discusses the current state of Racket’s testing ecosystem and presents a toolkit of packages to improve it. The toolkit packages add support for unit testing side effects with mocks, integration testing with fixtures, and abstracting over tests with composable first-class assertions. The packages are for the most part independent but designed to work together, and are built on top of a few general purpose libraries that can be used for non-testing purposes. There’s far more work to be done however, and this talk highlights what other forms of testing aspiring Racketeers ought to write packages for so I don’t have to.

Slides Source

Slideshow is a programming language for producing presentations. It’s extremely powerful, and has great tooling, but it’s anything but simple, even for experienced Racketeers. I present “slideshow/simple”, a language inspired by markdown and a tool called “sent” that simplifies the creation of DWIM presentations, for when you just need to put something on screen without a lot of fuss.

Slides

Do you enjoy automating with shell scripts, but find you need to toss out your Bash implementation in favor of using a “real” programming language as your script grows? Do you find yourself writing in Racket wishing you could throw down a quick pipeline of five processes without several lines of port and process juggling? Do you wish your interactive Bash shell were more like a Racket repl, or that your Racket repl were more like Bash? In this talk I describe my solution to these problems and more: Rash, the shell language for Racket.

Slides

Racket, as a language, excels at and encourages a style of linguistic abstraction using metaprogramming. One of the most potentially useful tools to a metaprogrammer is intimate knowledge of expressions’ types, but existing general purpose, statically typed languages do not make that information easily accessible to the macro writer. This talk presents an early, experimental version of Hackett, an embedding of a Haskell-style type system in Racket’s macro system. Hackett attempts to provide a robust typechecker with friendly, powerful type inference for general-purpose programs that simultaneously exposes that information to Racket’s ordinary macro-writing facilities.

Slides

In my computer architecture course, we study the full stack of CPU design from basic components (like adders) through microarchitecture, microcode, IO & interrupt systems, and through assembly using the MIC-1 by Tanenbaum. Students use tools for simulating the CPU, compiling the microcode, and assembling the macrocode. In previous years, I used a C-based suite (3779 LOC) which was very painful to use and maintain. For my most recent offering, I rewrote all of the tools in Racket (with 55% less code, including an extensive test-suite and more features!) In order to do this well, I wrote a general purpose hardware description DSL in Racket with three different backends, including compilers to C and LLVM IR. In this talk, I’ll discuss how to design compilers and DSLs like this in Racket and give a brief explanation of some fun microarchitecture points.

Slides

In massive programming courses, automated hint generation offers the promise of zero-cost, zero-latency assistance for students who are struggling to make progress on solving a program.

In this talk, I will describe a robust hint generation system for Racket programming assignments that extends the hint coverage of the mutation-based approach using two complementary techniques. A syntax checker detects common syntax misconception errors in individual subexpressions to guide students to partial solutions that can be evaluated for the semantic correctness. A mutation-based approach is then used to generate hints for almost-correct programs. If the mutation-based approach fails, a case analyzer detects missing program branches to guide students to partial solutions with reasonable structures. Our system itself is implemented in Racket. We utilize Rosette, a solver-aided language embedded in Racket, as a constraint solver to prove program equivalence.

After analyzing over 75,000 program submissions and 8,789 hint requests from UC Berkeley’s introductory computer science course, we found that using all three techniques together could offer hints for any program, no matter how far it was from a correct solution. Furthermore, our analysis shows that hints contributed to students’ progress while still encouraging the students to solve problems by themselves.

Slides

Three things that don’t normally go together are intuitionistic type theory, Racket as a teaching language, and a required sophomore course in logic and computation. I’ll describe how I’ve been teaching the course by having students code a small proof assistant (Proust) in Racket and using it to do their homework. Its construction proceeds in stages through propositional and predicate logic, going as far as recursive functions on natural numbers before a lateral transition to Coq.

Slides

Racket is the official language at Biomantica Inc, the biotech startup I co-founded. I had a little experience with it in advance and my cofounder learned it from scratch as we worked. In this talk we’ll go over why we chose it, the pros and cons we’ve found, the process of learning Racket on the job, and thoughts on how it worked out in practice.

Slides

Want to embrace the power of Racket in the ugly JavaScript world? RacketScript can compile Racket (ok! not all of it) to JavaScript. I’ll will demonstrate how the RacketScript compiler works, currently implemented features of Racket, and how it differs from Racket and other Racket to JavaScript compilers.