1 Racket, Historically Speaking

In 1995, we set out to create an outreach project for novice programmers. After observing students in labs over the course of a year, we understood that nobody could teach Scheme in an hour and then focus on the essence of computing and programming—contrary to an opinion widely held by instructors due to the numerous courses based on MIT’s Structure and Interpretation of Computer Programs (Abelson et al. 1985). What was needed, instead, was a teaching language suitable for instructing beginners. Furthermore, emacs, vi, and similar editors were overwhelming students who had never programmed before, despite their special modes for editing and interacting with Scheme. We therefore also wanted a pedagogical programming environment for our beginners, not just a re-appropriated power tool for professionals.

After we decided to implement our own teaching language and its environment, we still wanted to demonstrate that Scheme was an excellent implementation vehicle for these projects. We thought Scheme’s macro system would help us experiment with language designs. The language also appeared to be a perfect match for constructing a simple interactive development environment (IDE); after all, many Lisp courses taught how to create a read-eval-print loop, and a lot of emacs was written in Lisp.

Using Scheme as a starting point turned out to be an acceptable choice, but we soon found we needed a lot more. We discovered that more was needed than a hygienic and pattern-oriented variant of Lisp’s old macros. In the same vein, the development of a large system exposed the difference between having safe abstractions and mimicking them via lambda. Finally, implementing an IDE also called for executing arbitrary programs under the control of our own program—and this goal clarified that Scheme did not come with the means for managing resources and for ensuring the security of the hosting program.

Over time, we adapted Scheme to serve our needs. We built a syntax extension system on top of Scheme’s macros, added mechanisms for the creation of safe abstractions, and turned features of the surrounding operating system into linguistic constructs so that we could program resource administrators and security containers. In time, our language became a full-fledged tool for the working software engineer. By 2010, our dialect of Scheme had evolved so much that we renamed it to Racket (Flatt and PLT 2010) to let the world know that we had something different.