Overview

r/lisp is a subreddit dedicated to the discussion of Lisp, a family of programming languages known for their distinctive fully parenthesized prefix notation, dynamic typing, and powerful macro systems. The community serves as a hub for sharing code, learning resources, language implementations, and philosophical discussions about Lisp dialects such as Common Lisp, Scheme, Clojure, and Emacs Lisp. It fosters both beginner-friendly inquiry and advanced technical debate, reflecting the broader Lisp culture of experimentation and abstraction.

1 What is r/lisp?

1.1 Purpose and scope

r/lisp is a community on Reddit created for the exchange of knowledge, code, and opinions related to Lisp programming languages. Its scope covers all major Lisp dialects, historical implementations, and general Lisp philosophy. The subreddit welcomes questions from beginners, deep technical discussions, and sharing of projects or learning materials. It serves as a centralized forum for Lisp enthusiasts who use Reddit as their primary aggregator.

1.2 Relationship to other Lisp communities (e.g., comp.lang.lisp, IRC channels)

r/lisp coexists with older Lisp forums such as the Usenet group comp.lang.lisp and various IRC channels (e.g., #lisp on Freenode/Libera). While comp.lang.lisp traditionally hosted long-form technical debates, r/lisp offers a more modern, threaded, and upvote-driven interface. The subreddit often links to or references these other communities, and many members participate across multiple platforms. The relationship is complementary: r/lisp provides discoverability and accessibility, while the older forums maintain deep archival discussions and real-time chat.

1.3 Subreddit rules and moderation guidelines

1.3.1 On-topic content

The subreddit enforces a strict on-topic policy. Only content directly related to Lisp—including any dialect, implementation, tool, or historical aspect—is allowed. Posts about general programming concepts that happen to mention Lisp tangentially are typically removed. Moderation encourages posts that contribute to learning, debate, or project sharing.

1.3.2 No self-promotion or low-effort posts

r/lisp prohibits excessive self-promotion, such as repeated links to personal blogs or commercial products without substantive value. Low-effort posts such as simple “which language?” questions without prior research are also discouraged. The guidelines aim to maintain a high signal-to-noise ratio, consistent with the subreddit’s adult and intellectually rigorous tone.

2 History and milestones

2.1 Founding and early growth

r/lisp was created on January 25, 2008, during Reddit’s early expansion into programming subcommunities. Initially the subreddit grew slowly, reflecting the niche audience for Lisp. By 2010, with the rise of Clojure and renewed interest in functional programming, membership began to increase steadily. The community crossed 10,000 subscribers around 2013 and continued to grow.

2.2 Notable events and AMAs

2.2.1 AMA with Lisp creators or maintainers

Several prominent Lisp figures have participated in Ask Me Anything threads on r/lisp. Notable examples include AMAs with Common Lisp implementors (e.g., those behind SBCL and ECL), Scheme maintainers, and Clojure core team members. These events allow the community to ask direct questions about design decisions, future directions, and personal experiences.

2.2.2 Annual “Lisp Game Jam” announcements

The subreddit has become a primary announcement venue for the Lisp Game Jam, an annual event where participants create games in Lisp dialects. Posts detailing rules, themes, and submission deadlines attract high engagement and encourage community-driven projects. The jam has contributed to the creation of many shareable Lisp projects.

As of mid-2025, r/lisp has over 60,000 subscribers. Traffic peaks during major conferences (e.g., European Lisp Symposium) and after release announcements of major implementations. The subreddit’s growth has been steady but moderate, reflecting Lisp’s small but dedicated user base. Most visitors come from English-speaking countries, with significant minorities from Europe and Asia.

3 Common discussion topics

3.1 Language dialects and implementations

3.1.1 Common Lisp

Common Lisp is the most frequently discussed dialect on r/lisp. Threads cover its standard, implementation-specific features, performance comparisons (e.g., SBCL vs. CCL), and the Common Lisp Object System (CLOS). Many community members use Common Lisp for production software and share practical experiences.

3.1.2 Scheme and Racket

Scheme and its descendant Racket are popular among educators and students. Discussions often focus on the Scheme Reports (R5RS, R7RS), the Racket ecosystem, and pedagogical tools like DrRacket. The community sometimes debates the relative merits of Scheme’s minimalism versus Common Lisp’s comprehensiveness.

3.1.3 Clojure

Clojure, a modern Lisp dialect that runs on the JVM and other platforms, generates significant discussion due to its emphasis on functional programming and immutable data structures. Threads about Clojure often intersect with Java interoperability, the ClojureScript compiler, and concurrency abstractions like core.async.

3.1.4 Emacs Lisp

Emacs Lisp (Elisp) is discussed in the context of the Emacs text editor. Topics include writing extensions, configuration best practices, and comparisons with other scripting languages. Many r/lisp members are Emacs users, so Elisp threads frequently appear alongside general Lisp discussions.

3.2 Learning resources and beginner help

The subreddit maintains a consensus on key textbooks. *Practical Common Lisp* by Peter Seibel is often recommended for Common Lisp beginners. *Structure and Interpretation of Computer Programs* (SICP) remains a classic for Scheme, though some newer members advocate for *How to Design Programs* (HTDP). *The Joy of Clojure* and *Land of Lisp* are also frequently cited.

3.2.2 Online tutorials and interactive courses

Members share links to interactive platforms such as Exercism’s Lisp tracks, the “Little Lisper” book online, and Clojure-specific sites like “Clojure for the Brave and True.” The subreddit also highlights free courses like the University of Washington’s Lisp course and MIT’s online SICP lectures.

3.3 Advanced topics

3.3.1 Macros and metaprogramming

Macros, the quintessential Lisp feature, are a perennial advanced topic. Discussions compare hygienic macros (Scheme’s syntax-rules) with anaphoric macros (Common Lisp’s define-modify-macro). Users share macro patterns, pitfalls, and techniques for building domain-specific languages (DSLs).

3.3.2 Continuations, call/cc, and monads in Scheme

Scheme’s first-class continuations (call/cc) generate deep technical threads, often exploring control flow manipulation, coroutines, and back-tracking. Some posts draw parallels to monads in Haskell, sparking cross-language debates about abstraction power and performance trade-offs.

3.3.3 Threading, concurrency, and parallel Lisp

Concurrency models across Lisp dialects are compared: Common Lisp’s Bordeaux-Threads, Clojure’s parallel combinators and agents, and Scheme’s future-based libraries. Issues of data races, locks, and software transactional memory are discussed, especially in the context of modern multicore hardware.

3.4 Tooling and ecosystem

3.4.1 IDEs and editors (SLIME, Sly, CIDER)

SLIME (Superior Lisp Interaction Mode for Emacs) is the de facto environment for Common Lisp development. Sly, a fork, offers additional features. For Clojure, CIDER (Clojure Interactive Development Environment that Rocks) is widely recommended. Posts often cover configuration tips and integration with REPL-driven development.

3.4.2 Package managers (Quicklisp, Leiningen)

Quicklisp serves as the standard package manager for Common Lisp, enabling easy installation of libraries. Leiningen (or “lein”) performs a similar role for Clojure, also handling project templating and build automation. Discussions compare these tools to language-agnostic alternatives like Git submodules.

3.4.3 Build systems and deployment

Topics include deploying Lisp applications to servers, using Docker containers with Lisp images, and embedding Lisp in other systems. For Common Lisp, ASDF (Another System Definition Facility) is the build system of choice; for Clojure, tools like deps.edn and tools.build are common. Threads often address cross-platform compilation and shebang scripts.

4 Community culture and norms

4.1 Tone and etiquette: intellectual rigor and patience

r/lisp values intellectual rigor. Users expect detailed, well-researched answers and are tolerant of persistent questioning. Beginners are treated with patience, but off-topic or drive-by posts are downvoted or removed. The community prides itself on avoiding the confrontational tone found in some other programming subreddits.

4.2 Humor and inside jokes (e.g., “Lisp is a religion”)

4.2.1 Parentheses memes and formatting debates

Lighthearted memes about Lisp’s heavy use of parentheses are common, often parodying the view that Lisp code is “fireworks” of parentheses. Some threads satirize formatting styles (e.g., closing many parentheses on one line vs. aligned vertically). These jokes are self-aware and accepted as part of the culture.

4.2.2 “Lisp is the greatest language” vs. “Lisp is dead” discussions

A recurrent trope is the exaggerated declaration that “Lisp is the greatest language ever created,” followed by counter-debates that Lisp is a niche relic. These threads often become meta-commentaries on language popularity and innovation. The subreddit uses these discussions to explore deeper truths about language design rather than to provoke.

4.3 Relation to other programming subreddits

r/lisp maintains friendly cross-links with r/Common_Lisp, r/scheme, r/Clojure, and r/EmacsLisp. It also occasionally interacts with r/functionalprogramming and r/programming. While members may criticize other language communities for bloat or trendiness, the tone is generally respectful.

5 Notable threads and recurring debates

5.1 “Which Lisp should I learn first?”

This perennial post asks newcomers which Lisp dialect to start with. Responses typically recommend Common Lisp for its “batteries included” approach, Scheme for its simplicity, or Clojure for Java ecosystem access. The thread often devolves into a list of pros and cons, but a consensus usually forms around the learner’s goals.

5.2 “Why doesn’t Lisp have more adoption?”

A reflective debate examining Lisp’s limited mainstream success. Arguments cite its unfamiliar syntax, lack of corporate backing, fragmentation of implementations, and the “code as data” paradigm’s steep learning curve. Counterpoints highlight Lisp’s influence on other languages and its enduring use in niche domains.

5.3 Macro vs. function trade-offs

Technical threads compare the use of macros versus higher-order functions for code abstraction. Points of contention include hygiene, compile-time optimization, and readability. The debate often references real-world examples from Common Lisp and Scheme, and occasionally extends to Clojure’s “macro without compassion” warnings.

5.4 Static vs. dynamic typing in Lisp

Despite Lisp’s default dynamic typing, some dialects (e.g., typed Racket) and type inference tools (e.g., Coalton for Common Lisp) spark discussions about the benefits of optional static typing. The community weighs pros such as better error checking against cons such as increased code verbosity and loss of dynamic flexibility.

6.1 Official Lisp websites and mailing lists

The sidebar of r/lisp provides links to the Common Lisp community’s standards page, the Scheme Reports, Clojure’s official site, and the Emacs Lisp manual. Mailing lists such as comp.lang.lisp and the LispM list are also referenced. These resources serve as authoritative references for discussions.

6.2 Podcasts (e.g., LispCast, Functional Geekery)

Podcasts dedicated to Lisp frequently appear in recommendations. LispCast covers Common Lisp news and tutorials. Functional Geekery features interviews with Lisp practitioners and functional programmers. The subreddit occasionally hosts AMAs with podcast hosts.

6.3 Conferences and meetups (e.g., European Lisp Symposium, Clojure/conj)

r/lisp promotes major Lisp conferences. The European Lisp Symposium (ELS) is the flagship academic event for Common Lisp and Scheme. Clojure/conj focuses on Clojure development. International Lisp Conference (ILC) and regional Lisp meetups are also announced. Posts often include call-for-papers, schedule highlights, and after-event summaries.