November 28, 2025
The creator of Ruby — Yukihiro “Matz” Matsumoto — has acknowledged that Ruby draws from a mosaic of languages: Perl, Smalltalk, Eiffel, Ada and Lisp. noelrappin.com
In his “Ruby And Its Neighbors” series, Noel Rappin turns to Lisp to reflect on what parts of Lisp — if any — live on in Ruby today. This article distills his main observations, and what a Rubyist might gain from revisiting Lisp’s philosophy.
Bring Your Next Project to Life with High-Quality Development
Don’t miss the opportunity to take your project to the next level. Whether you want to launch something new or improve an existing platform, we build maintainable, scalable software that empowers your business.
Available for freelance and team-based projects • Fast replies
The Essence of Lisp — Code as Data, Simplicity and Power
- Uniform syntax: lists. In Lisp, both code and data are represented with lists. A snippet like
(1 2 3 4)
(car '(1 2 3 4))
- Linked-list as core data structure. Historically, Lisp’s lists were implemented as linked pairs — car for the first element, cdr for the rest. This naturally reflected Lisp’s list-processing roots. noelrappin.com+1
- Homoiconicity — code is data. Because Lisp represents code with its core data structures, it becomes trivial for Lisp code to generate, inspect, and manipulate other Lisp code. This enables powerful metaprogramming: macros, domain-specific languages (DSLs), code-generation, and more. noelrappin.com+1
- Interactive and dynamic development. Lisp’s typical environment is a REPL: you type expressions, evaluate them on the fly, inspect results, redefine functions or data, and continue. This fluid interactivity fosters experimentation and rapid feedback. noelrappin.com
- Powerful macro system. Macros in Lisp aren’t just functions — they’re transformations from data (lists) to executable code (lists), run at compile/interpret time. That allows creation of new syntactic constructs, DSLs, abstractions — things that closely match program intent. noelrappin.com
Lisp’s lean core plus metaprogramming capacities gives extraordinary flexibility: programmers build exactly what they need, shaping the language to the problem at hand. As Rappin puts it — Lisp feels like “a bunch of small, well-designed Lego bricks.” noelrappin.com
Why Lisp Doesn’t Look Like Ruby — But Its Spirit Lives On
Despite its influence, Ruby doesn’t look like Lisp: Ruby syntax is more conventional, less parenthesis-heavy, and more oriented toward object-oriented, imperative programming. So what did Ruby “take” from Lisp?
According to Rappin: noelrappin.com
- Everything is an expression. In Lisp, almost everything evaluates to something — expressions, conditionals, definitions. Ruby inherits this mindset.
- Metaprogramming and DSLs. The idea of building mini-languages or domain-specific abstractions at runtime is central in Lisp. Ruby, with its open classes, blocks, reflection, and metaprogramming capabilities, mirrors that philosophy.
- Flexible symbol vs. string distinction. Lisp draws a clear line between symbols (which often represent identifiers) and strings (text), a distinction that influences how Lisp handles identifiers and data. Ruby — while not homoiconic — maintains some flavor of this distinction when using symbols in hashes, method names, etc.
Rappin argues that Ruby didn’t “borrow parentheses or list-based syntax,” but borrowed “vibes” — the flexibility, the metaprogramming-friendly mindset, the readiness for domain-specific abstractions. noelrappin.com
Lisp’s Rise and Fade — A Bit of Historical Context
Lisp is one of the oldest high-level languages still in use. Created in the late 1950s by John McCarthy and collaborators, Lisp was initially conceived for symbolic computation and later became a dominant language in AI research. Wikipedia+1
Over decades, several dialects emerged, of which the most prominent today are:
- Common Lisp — descendant of the original Lisp, evolved with many standard libraries and features. noelrappin.com+1
- Scheme — a simpler, minimalist Lisp dialect, famous for being used in the textbook Structure and Interpretation of Computer Programs. noelrappin.com+1
- Clojure — a modern Lisp dialect (on the JVM), which blends Lisp ideas with practical features and interoperability in today’s ecosystems. noelrappin.com
Although Lisp was once deeply linked to AI research and early computing, over time its popularity waned in mainstream commercial software development. According to Rappin, this decline wasn’t because Lisp got suddenly bad — rather, other languages and ecosystems became more convenient for the everyday tasks most developers face, and Lisp’s strengths (like homoiconicity or macros) started to feel niche in a world driven by frameworks, libraries, and standardized tooling. noelrappin.com
Still — the “Lisp way” survives. As Rappin notes, languages like Ruby (and others) borrowed the spirit of Lisp even if not its syntax. noelrappin.com
Why a Ruby Developer Should Care About Lisp
Given your background in Ruby (and interest in design patterns, Rails, etc.), revisiting Lisp may be more than historical curiosity:
- Metaprogramming and DSL inspiration : Studying Lisp macros and its flexible syntax/data duality can spark ideas for Ruby DSLs or meta-programming patterns.
- Thinking in expressions : Lisp’s philosophy — code is data, everything is an expression — may influence how you structure code, even in an OO or procedural Ruby project.
- Appreciating alternative programming paradigms : Lisp has deep roots in functional programming, symbolic processing, and REPL-driven development. Understanding this can broaden how you approach problems, sometimes beyond the “Ruby way.”
- Historical and conceptual grounding : Recognizing where Ruby ideas come from (Perl, Smalltalk, Lisp…) gives you a deeper sense of why Ruby behaves the way it does and helps you use its strengths more intentionally.
Conclusion — More Than Parentheses: A Legacy of Flexibility
Lisp may not have given Ruby parentheses or its list-based syntax — but it gave Ruby something arguably more precious: a mindset. A mindset where code is malleable, where abstractions matter, where metaprogramming and DSLs are part of the programmer’s toolbox.
As Noel Rappin reflects: working in Lisp is “like being handed beautiful, small Lego bricks.” Ruby may look different, but the philosophy of building — of designing code that expresses intent cleanly, elegantly, and flexibly — lives on.
If you’re curious… maybe it’s time to open a REPL, try a Lisp dialect, and play with those Lego bricks yourself.
Top comments (0)