A little over a decade ago, there were some popular blogposts about whether
Ruby was an acceptable Lisp
or whether even
Lisp was an acceptable Lisp.
Peter Norvig was also writing at the time
introducing Python to Lisp programmers.
Lisp, those in the know knew, was the right thing to strive for, and yet
seemed unattainable for anything aimed for production since the AI Winter
shattered Lisp’s popularity in the 80s/early 90s.
If you can’t get Lisp, what’s closest thing you can get?

This was around the time I was starting to program; I had spent some
time configuring my editor with Emacs Lisp and loved every moment I
got to do it; I read some Lisp books and longed for more.
And yet when I tried to “get things done” in the language, I just
couldn’t make as much headway as I could with my preferred language
for practical projects at the time: Python.

Python was great… mostly.
It was easy to read, it was easy to write, it was easy-ish to teach
to newcomers.
(Python’s intro material is better than most, but my spouse has talked before about some major pitfalls
that the Python documentation has which make getting started
unnecessarily hard.
You can
hear her talk about that
at this talk we co-presented on at last year’s RacketCon.)
I ran a large free software project on a Python codebase, and it was
easy to get new contributors; the barrier to entry to becoming a
programmer with Python was low.
I consider that to be a feature, and it certainly helped me bootstrap
my career.

Most importantly of all though, Python was easy to pick up and run with
because no matter what you wanted to do, either the tools came built
in or the Python ecosystem had enough of the pieces nearby that building
what you wanted was usually fairly trivial.

But Python has its limitations, and I always longed for a lisp.
For a brief time, I thought I could get there by contributing to the
Hy project, which was a lisp
that transformed itself into the Python AST.
“Why write Python in a syntax that’s easy to read when you could add
a bunch of parentheses to it instead?” I would joke when I talked about
Believe it or not though, I do consider lisps easier to read, once you
are comfortable to understand their syntax.
I certainly find them easier to write and modify.
And I longed for the metaprogramming aspects of Lisp.

Alas, Hy didn’t really reach my dream.
That macro expansion made debugging a nightmare as Hy would lose track
of where the line numbers are; it wasn’t until that when I really realized
that without line numbers, you’re just lost in terms of debugging in
That and Python didn’t really have the right primitives; immutable
datastructures for whatever reason never became first class, meaning
that functional programming was hard, “cons” didn’t really exist
(actually this doesn’t matter as much as people might think), recursive
programming isn’t really as possible without tail call elimination, etc
etc etc.

But I missed parentheses.
I longed for parentheses.
I dreamed in parentheses.
I’m not kidding, the only dreams I’ve ever had in code were in lisp,
and it’s happened multiple times, programs unfolding before me.
The structure of lisp makes the flow of code so clear, and there’s
simply nothing like the comfort of developing in front of a lisp REPL.

Yet to choose to use a lisp seemed to mean opening myself up to
eternal yak-shaving of developing packages that were already available
on the Python Package Index or limiting my development community an
elite group of Emacs users.
When I was in Python, I longed for the beauty of a Lisp; when I was in
a Lisp, I longed for the ease of Python.

All this changed when I discovered Racket:

  • Racket comes with a full-featured editor named DrRacket built-in
    that’s damn nice to use.
    It has all the features that make lisp hacking comfortable previously
    mostly only to Emacs users: parenthesis balancing, comfortable REPL
    integration, etc etc.
    But if you want to use Emacs, you can use racket-mode.
  • Racket has intentionally been built as an educational language, not
    unlike Python.
    One of the core audiences of Racket is middle schoolers, and it even
    comes with a built-in game engine for kids.
    (The How to Design Programs prologue
    might give you an introductory taste, and Realm of Racket
    is a good book all about learning to program by building Racket games.)
  • My spouse and I even taught classes about how to learn to program for
    humanities academics
    using Racket.
    We found the age-old belief that “lisp syntax is just too hard” is
    simply false; the main thing that most people lack is decent lisp-friendly
    tooling with a low barrier to entry, and DrRacket provides that.
    The only people who were afraid of the parentheses turned out to be people
    who already knew how to program.
    Those who didn’t even praised the syntax for its clarity and the way
    the editor could help show you when you made a syntax error
    (DrRacket is very good at that).
    “Lisp is too hard to learn” is a lie; if middle schoolers can learn it,
    so can more seasoned programmers.
  • Racket might even be more batteries included than Python.
    At least all the batteries that come included are generally nicer;
    Racket’s GUI library is the only
    time I’ve ever had fun in my life writing GUI programs (and they’re cross
    platform too).
    Constructing pictures with its pict
    library is a delight.
    Plotting graphs with plot
    is an incredible experience.
    Writing documentation with
    is the best non-org-mode experience I’ve ever had, but has the
    advantage over org-mode in that your document is just inverted code.
    I could go on.
    And these are just some packages bundled with Racket; the
    Package repository contains much more.
  • Racket’s documentation is, in my experience, unparalleled.
    The Racket Guide walks
    you through all the key concepts, and the
    Racket Reference
    has everything else you need.
  • The tutorials are also wonderful; the
    introductory tutorial
    gets your feet wet not through composing numbers or strings but by
    building up pictures.
    Want to learn more?
    The next two tutorials show you how to
    build web applications
    and then
    build your own web server.
  • Like Python, even though Racket has its roots in education, it is more than
    ready for serious practical use.
    These days, when I want to build something and get it done quickly
    and efficiently, I reach for Racket first.

Racket is a great Lisp, but it’s also an acceptable Python.
Sometimes you really can have it all.

Read More


Please enter your comment!
Please enter your name here