It All Starts with Lisp
To understand Racket, you have to start with its ancestor: Lisp. Racket is a modern descendant of the Lisp family of languages, by way of a dialect called Scheme. The most famous characteristic of this family is its uniform syntax, known as S-expressions
(or symbolic expressions). In simple terms, everything is a list enclosed in parentheses. The first item in the list is the operation or function, and the rest are the arguments. For example, adding 2 and 3 isn't written as `2 + 3`, but as `(+ 2 3)`. This might seem strange, but this consistency is the foundation of the language's power. It means there's no need to memorize complex rules about operator precedence; the nested structure of the parentheses dictates the order of operations explicitly.
Code Is Data, Data Is Code
The most profound consequence of using S-expressions is a concept called homoiconicity, a fancy term meaning the code has the same structure as its data. In Racket, a list of numbers is written `(1 2 3)`, and a piece of code that adds those numbers might look like `(+ 1 2 3)`. Notice how similar they are. This isn't an accident. Racket's parser, the part of the system that reads your code, doesn't see a complex set of grammatical rules; it just sees nested lists. This makes the language incredibly simple at its core. More importantly, it means that a Racket program can treat its own code as data—to be constructed, analyzed, and manipulated just like any other list. This opens the door to a technique called metaprogramming, which is where Racket's syntax really starts to shine.
The Superpower: Macros and Metaprogramming
Because code is just a data structure, Racket allows developers to write programs that write programs. This is done through a powerful macro system. Unlike simple text-replacement macros found in other languages, Racket's macros operate on the structure of the code itself. A macro is a function that runs at compile time, taking code (as a list-like structure) as input and transforming it into new code before the program is executed. This allows you to extend the language itself. Don't like how a certain feature works? Write a macro to create a new syntax that behaves exactly as you want. This feature is so central that many of Racket's own constructs, like its class and module systems, are built using this very macro system.
A Language for Making Languages
This all leads to the core philosophy behind Racket, as detailed by its creators in "The Racket Manifesto": Racket is a programming language designed for creating other programming languages. This is often called "language-oriented programming." The idea is that different problems are best solved with different languages. Instead of being stuck with one set of rules, Racket empowers developers to quickly create small, domain-specific languages (DSLs) tailored to a particular task. For example, the first line of a Racket file, `#lang racket`, explicitly declares which language the rest of the file is written in. But you can just as easily write `#lang honu` to use a C-like syntax or `#lang scribble` for a documentation language—all running on the same Racket platform. The parenthesis-based syntax is what makes this possible, providing a universal, simple foundation upon which countless other syntaxes and language features can be built.
