A Friendly Introduction to Racket

Aug 22, 2026 09:08 PM - 4 hours ago 1

11 Aug, 2026

steal-your-face-plt

"Lisp is worthy learning for the profound enlightenment acquisition you will person erstwhile you yet get it." — Eric S. Raymond

Welcome. Today you'll study a connection from 1 of programming's oldest and astir different families. A connection wherever codification is data, wherever parentheses are axenic structure, and wherever programs tin constitute programs. By the extremity of this tutorial, you'll person written your ain syntax.

A spot of history

Lisp was calved successful 1958, invented by John McCarthy astatine MIT. For context: it's the second-oldest high-level connection still successful usage (only Fortran, from 1957, thumps it by a year). Python arrived successful 1991. JavaScript successful 1995. Lisp predates them by much than 30 years and respective ideas we now see "modern" were calved there:

Garbage collection — invented for Lisp.
First-class functions — passing functions arsenic arguments, now modular everywhere.
The REPL — the interactive read-eval-print loop that Python, Node, and Julia each person coming started successful Lisp.
Conditionals arsenic expressions — the if that returns a value.
Homoiconicity — codification is a information building of the connection itself. This is the large one. We'll travel backmost to it astatine the end.

For decades, Lisp was the connection of artificial intelligence. In the 70s and 80s location were beingness computers designed to tally Lisp directly: the Lisp Machines built by Symbolics and LMI. Then came the "AI winter," backing dried up, and Lisp went from prima to cult language.

But absorbing ideas don't dice they mutate, that's portion of the beauty of the lisps.

From Lisp to Scheme to Racket

In 1975, Gerald Sussman and Guy Steele created Scheme: a minimalist, elegant, almost mathematical Lisp. Scheme became academia's favourite connection for teaching programming (the legendary book SICP Structure and Interpretation of Computer Programs is written successful Scheme).

In 1995, Matthias Felleisen's group created PLT Scheme, a Scheme designed for acquisition and programming connection research. In 2010 it was renamed Racket, and coming it's overmuch much than a Scheme: it's a connection for building languages. Its unofficial motto is language-oriented programming: if your problem needs its ain language, Racket lets you build 1 successful an afternoon.

Year Event

1958	McCarthy invents Lisp astatine MIT
1975	Sussman and Steele create Scheme
1984	Common Lisp is standardized
1995	PLT Scheme (now Racket) is born
2007	Clojure is calved (Lisp connected the JVM)
2010	PLT Scheme is renamed Racket
Today	You, reference this, astir to constitute parentheses UwU

Who uses Lisp today?

More group than you mightiness think:

Clojure runs successful accumulation astatine banks, airlines, and startups (Nubank, the largest integer slope successful Latin America, runs connected Clojure).
Common Lisp (with the SBCL compiler) is still live successful master systems, formation readying (ITA Software, acquired by Google, powered Google Flights), and technological computing.
Emacs Lisp — millions of group tally Lisp each time without knowing it, because their editor is a Lisp interpreter.
Guile/Guix — an full Linux distribution configured 100% successful Scheme.
Racket has its ain yearly convention (RacketCon), an progressive world and creator community, and is utilized for connection research, general verification (Rosette), typography and publishing (Pollen), and acquisition astir the world.
And caller Lisps support appearing: Fennel (a Lisp that compiles to Lua, celebrated for games), Janet, Hy (a Lisp connected apical of Python)...

Easter ovum for TADC fans:

TADC

In The Amazing Digital Circus (episode 8, "hjsakldfhl"), erstwhile Kinger opens the terminal to effort to reset Caine, you tin spot that Caine (a imaginative AI built successful 1996) is programmed successful Lisp. The record is virtually named Caine-core.lisp.

Installation (5 minutes)

Go to https://racket-lang.org
Download the installer for your strategy (Linux, macOS, Windows).
Open DrRacket, the situation that comes included.

DrRacket has 2 areas: astatine the apical you constitute your definitions (your program), and astatine the bottommost you person the REPL for unrecorded experimentation. On the first statement of the definitions area, write:

That statement tells Racket which connection you're utilizing (remember: Racket is simply a connection factory, truthful you person to prime one).

If you for illustration the terminal: the racket bid gives you a REPL, and raco is the package head and tooling command.

In the REPL, try:

> (+ 1 2) 3 > (* 3 (+ 2 2)) 12 > (string-append "hello " "world") "hello world"

The norm of Lisp fits successful 1 line:

Everything is (operator argument1 argument2 ...). Always. No exceptions.

There's nary usability precedence to memorize, nary typical syntax for anything. (+ 1 2) adds. (if ...) decides. (define ...) names. The parentheses that look intimidating astatine first are really the complete absence of arbitrary rules. After a week, you extremity seeing them.

Definitions and functions

#lang racket (define pi-approx 3.14159) (define (circle-area r) (* pi-approx r r)) (circle-area 2) ; => 12.56636

define pinch a sanction creates a constant.
define pinch (name arguments...) creates a function.
Comments commencement pinch ;.

Anonymous functions usage lambda (yes, that lambda Church's lambda calculus from the 1930s is the theoretical grandparent of each this):

(lambda (x) (* x x)) ; a usability pinch nary name ((lambda (x) (* x x)) 5) ; => 25, applied directly

Lists: the bosom of Lisp

Lisp stands for LISt Processing. Lists are the basal structure:

(list 1 2 3) ; => '(1 2 3) '(1 2 3) ; the aforesaid thing, "quoted" (first '(1 2 3)) ; => 1 (rest '(1 2 3)) ; => '(2 3) (cons 0 '(1 2 3)) ; => '(0 1 2 3) (length '(a b c)) ; => 3

Notice the quote people '. It tells Racket: don't measure this, it's data. Hold onto that item it's the doorway to the last trick.

Higher-order functions

This is wherever Racket shines. Passing functions to different functions is the astir earthy point successful the world:

(map (lambda (x) (* x x)) '(1 2 3 4 5)) ; => '(1 4 9 16 25) (filter even? '(1 2 3 4 5 6)) ; => '(2 4 6) (foldl + 0 '(1 2 3 4 5)) ; => 15

map transforms, select selects, foldl accumulates. With those 3 functions you tin lick astir database problems without penning a azygous for loop.

Recursion: reasoning successful spirals

In Lisp you don't deliberation "repeat N times" you deliberation "what's the guidelines case, and really do I move toward it?":

(define (factorial n) (if (= n 0) 1 (* n (factorial (- n 1))))) (factorial 5) ; => 120

And to make things visual, let's tie something. Racket ships pinch graphics libraries included:

#lang racket (require 2htdp/image) (define (sierpinski level) (if (= level 0) (triangle 8 "solid" "purple") (let ([t (sierpinski (- level 1))]) (above t (beside t t))))) (sierpinski 6)

Paste it into DrRacket, property Run, and watch the Sierpinski triangle look connected your screen.

The expansive finale: codification that writes code

Remember the quote people ': it turns codification into data. Watch:

'(+ 1 2) ; => the LIST (+ 1 2), not the number 3 (first '(+ 1 2)) ; => the awesome + (eval '(+ 1 2)) ; => 3. You conscionable evaluated information arsenic code.

Your programme is simply a list. You tin build lists. Therefore: you tin build programs pinch programs. This is homoiconicity, and it's why Lisp has existent macros not matter macros for illustration successful C, but functions that person codification and return code, earlier thing runs.

Racket doesn't person a while loop? Let's invent one:

(define-syntax-rule (while condition body ...) (let loop () (when condition body ... (loop)))) (define counter 0) (while (< counter 5) (displayln counter) (set! counter (+ counter 1)))

You conscionable extended the connection ! successful Lisp, the syntax is yours.

Alan Kay called Lisp "the Maxwell's equations of software": a mini halfway from which everything other tin beryllium derived.

What next?

Kurosawa_Ruby_Holding_SICP

How to Design Programs — the book Racket was designed around, free online.
The Racket Guide — charismatic documentation, among the champion retired there.
Beautiful Racket — study to build your ain languages.
SICP — the classical of classics, if you want the afloat enlightenment.