How do I get started with Racket?

You keep hearing good things about Racket. You get the impression that if you want to get into Lisp—and especially if you want to get into making domain-specific languages and language-oriented programming—then Racket is a great choice.

But you just don’t have time to pick up a new language. You’re a busy programmer. Racket looks cool, but where’s the structure for learning it? You’ve got better things to do than to try to reverse-engineer your own handcrafted course from the official docs or aimlessly scrounge around for the good bits among countless documentation pages, blog posts, StackOverflow questions, Quora answers, you name it. And you don’t need a college course on introductory computer science where Racket just happens to be the language used to illustrate the ideas. You’re a working programmer, for crying out loud! You already learned that stuff and practice it every day.

You wish you could quickly see what Racket has to offer, before going whole hog. You don’t need anything BIG, just a little guidance to get you started. You know from experience that once you’re motivated to learn a programming language more deeply, you can probably figure it out from there and bootstrap your way up. You just need that little nudge to get started.

But the basic problem remains: You don’t know what you don’t know, so how do you even start? Are you sure you won’t miss something really special about Racket?

What if you could take a short structured excursion into Racket to find out what it’s all about? What if you could quickly take in some highlights and absorb the juicy parts of the language?

What if you had an opportunity to see a hand-selected bundle of great ideas illustrating what real-world Racket programming is like?

All it takes is a couple of days. The question is: What are you doing this weekend?

Make it a Racket weekend

Racket Weekend is a short course on the Racket programming language. Intended length: 2 days. (Of course, I’m not watching, so take it as slow or as fast as you want.)

Racket is big. They call it batteries included, and they’re not joking around. So if you’ve only got a weekend, it’s important to focus on the best that the language has to offer. In Racket Weekend, you’ll learn about the Racket approach to the following ideas:

Structure of programs and basic syntax: In which we begin the excursion by talking about what Racket programs look like, and how they’re structured. Modules. Basic data: numbers, strings, lists, functions.
The read-evaluate-print loop (REPL): A way to work with your programs directly. Easily one of the killer tools offered by Racket (and other Lisps, too).
Structures: First steps into defining your own data types and giving your data some structure.
Object-oriented programming: Racket comes out-of-the-box with a powerful object system. Learn the Racket approach to OOP. Bonus: mix and match OOP with non-OOP code.
Macros: Take the language into your own hands by writing functions that generate bits of language. Macros can greatly simplify your programs, and help open the door to making your own languages, one of Racket’s specialties.
Contracts: Your function’s value probably satisfies certain properties, assuming that the inputs do. Wrap your functions in contracts—an agreement between called and caller that is enforced by Racket.
Functional programming bricolage: Racket encourages functional programming without being doctrinaire about it. Learn about some of the idioms and basic ideas of FP, Racket-style.
Testing: Making sure that your functions do what you think they do—writing tests—is bread & butter programming. Racket offers a delightfully straightforward approach to testing that will make you really want to test.
Web programming: It’s fine and well to write Racket programs for yourself. But what if you want to expose your work via the web? Racket comes with a built-in HTTP server. Learn how to get started with it.
Documentation: Racket comes with its own language for documentation called Scribble. It makes writing documentation a real pleasure.
Packages: Learn how to find and install packages from the Racket community, as well as how to make your own and submit it to the Racket package server.

Why these topics?

The chosen topics represent a deliberately incomplete selection of Racket. A vast amount of material did not make the cull. The only complete discussion of Racket is the official documentation. And I think you’ll agree that that’s BIG and hard to approach.

These topics are everyday Racket. Stuff that you’re likely to use in essentially every Racket project. The list is a curated selection designed to be useful for the curious student of Racket. The aim is not to be opinionated, to be a course where the instructor struts his stuff, showing off advanced topics or delving into eclectic areas. The intention of Racket Weekend is to offer a stepping stone into the wider Racket world, to make Lisp more accessible & less scary. Racket Weekend is a bridge you can fairly quickly cross knowing that, when you get to the other side, you’re on more solid ground than you were before.

Versions of the course

Racket Weekend is available in three editions, each offering the course in various ways.

Couch Edition

The basic PDF ebook version of the course.

Library Edition

This edition includes the materials in the Couch Edition as well as worksheets in PDF format, which contain 45 exercises that ask you to go beyond the given material and make it your own. This version includes the ebook, too. Ideal for those who want to stretch themselves and be more active in their learning.

Classroom Edition

Finally, the most comprehensive version of Racket Weekend contains the ebook, the worksheets, and videos where I do conversational coding, talking about the exercises and solving them while you watch, adding some material that is not easily put into written form. This is the most comprehensive version of the course, offering insight into how one really works in Racket.

About your teacher

I’m Jesse Alama. I’ve been hacking Lisp (first Scheme, then Common Lisp, then Clojure, and most recently Racket) since 1996. I write about Racket over at lisp.sh. I’m the author of Server: Racket—Practical Web Development with the Racket HTTP Server and maintain a few Racket libraries:

argo (JSON Schema validator),
json-pointer (RFC 6901: JSON Pointer), and
uri-template (RFC 6570: URI Template)

I’m a coauthor of the entry on the lambda calculus in the Stanford Encyclopedia of Philosophy and have worked as a researcher in mathematics and computer science, primarily in automated theorem proving.