Weird Languages

In one sentence

To truly understand what programming can do, you must move beyond the "glue" of popular languages and explore "weird" languages that enable you to express—and therefore think—about problems in ways that are impossible in mainstream environments.

Why read this (and who it's for)

This is for the "competent" programmer who feels they have mastered the standard stack but finds themselves hitting a ceiling of expression. It solves the problem of intellectual plateaus: the realization that most of what we do is just arranging existing library calls. By reading this, you will learn how to identify the "0.5%" of programming that constitutes true innovation and how to use "weird" languages as a tool for expanding your mental models of what is possible.

The big idea

Most programming is a "glue" activity. Graham argues that 99.5% of what we do involves calling library functions and stitching them together. Because all popular languages are equally good at this, it is easy to spend an entire career operating within the "intersection" of popular languages without ever exploring the true boundaries of what programming can achieve.

The "weird" 0.5% of programming is where the real interest lies. "Weird" languages—those that are difficult to use or unconventional—are not weird by accident. Their weirdness is a signal that they allow for a form of programming that goes beyond simple glue-work. They offer a space of "program-manipulating techniques" that are not yet fully explored.

The ultimate goal of exploring these languages is not just to learn a new syntax. It is to learn how to "say" things you couldn't say before. By learning to express complex ideas in a weird language, you fundamentally change how you think about problems, expanding your conceptual reach beyond the limitations of common, "safe" programming.

Key ideas

The 99.5/0.5 Split

• What it is — Programming is divided into the mundane "glue" of calling library functions (99.5%) and the "interesting" core of programming (0.5%).
• Why it matters — If you only work in the 99.5% zone, you are essentially operating in a safe, crowded space where all popular languages behave the same way.
• In the book — Graham notes that "one can easily spend one's whole career operating in the intersection of popular programming languages."

The Intersection of Popularity

• What it is — The "safe" zone where most programmers live, where the tools and libraries are most accessible.
• Why it matters — While productive, this zone limits your ability to express certain types of logic because the language itself doesn't provide the necessary primitives.
• In the book — Graham argues that the "weirdness" of good languages is a clue that they offer something outside this intersection.

Intentional Weirdness

• What it is — "Weird" languages are not poorly designed; their unconventionality is a deliberate feature that enables unique programming techniques.
• Why it matters — You shouldn't view "weird" as a bug. Instead, view it as a signal of a capability that isn't available in standard languages.
• In the book — "The weirdness of the good ones usually implies the existence of some form of programming that's not just the usual gluing together of library calls."

Language as a Solution

• What it is — A technique where you solve a problem by first writing a specialized language for that problem, then writing your application in that new language.
• Why it matters — This moves you from "using" a tool to "creating" a tool specifically designed for the problem's unique constraints.
• In the book — Graham points to Lisp macros as a way of "solving problems by first writing a language for problems of that type."

Linguistic Expansion of Thought

• What it is — The idea that the limits of your language determine the limits of your thoughts.
• Why it matters — Learning a "weird" language is a way to expand your mental model of what is possible in software.
• In the book — "In the process of learning how to say things you couldn't previously say, you'll probably be learning how to think things you couldn't previously think."

Frameworks & tools

The "Weird Language" Expansion Framework

Use this to break out of the "glue" programming plateau:

1. Identify a "Weird" Language: Find a language that is considered "weird" by the mainstream but has a community of smart, capable users.
2. Identify the Intersection: Determine what you can currently say in your "normal" languages (the glue).
3. Find the "Impossible" Expressions: Identify what you can say in the weird language that would be "impossibly inconvenient" to say in your normal languages.
4. Internalize the New Logic: Practice expressing those specific ideas until they become part of your mental toolkit for solving problems.

Memorable examples & stories

Lisp Macros

Lisp macros are the quintessential example of "weird" programming. They allow you to manipulate the program itself, enabling you to build a custom language for a specific problem. Lesson: Use macros to create a domain-specific language (DSL) when the standard library feels like it's fighting your problem.

The "Intersection" of Popularity

Graham describes the space where most programmers live—the area where all popular languages overlap in their ability to glue library calls together. Lesson: Awareness of this "safe" zone is necessary to recognize when you are merely performing glue-work rather than solving a core architectural problem.

Key quotes

"99.5% of programming consists of gluing together calls to library functions. All popular languages are equally good at this." Why it matters: This identifies the "trap" of modern development—the ease of glue-work can mask a lack of deep architectural exploration.

"The weirdness of the good ones usually implies the existence of some form of programming that's not just the usual gluing together of library calls." Why it matters: It reframes "weirdness" as a feature of high-leverage programming.

"In the process of learning how to say things you couldn't previously say, you'll probably be learning how to think things you couldn't previously think." Why it matters: This is the ultimate "why"—the goal is cognitive expansion, not just a new skill.

How to apply it

This week

• Identify your "Safe Zone": List the 3-5 things you do most often in your current language. Are they just "gluing" library calls?
• Select a "Weird" Language: Choose one (e.g., Haskell, Lisp, or a niche functional language) and find a "smart" user's tutorial.
• Find one "Impossible" Expression: Find one thing that is easy to say in that weird language but hard in your current one.

Ongoing

• The "DSL" Test: Before reaching for a library to solve a complex problem, ask: "Would it be better to write a small, specialized language for this specific problem?"
• Expand the Space: When you encounter a problem that feels "unnatural" to solve in your current language, treat it as a signal to explore a "weird" language that might offer a more elegant expression.

Common pitfalls

• The "Complexity" Trap: Assuming that "weird" means "harder to use" in a way that adds no value. If a language is weird but doesn't allow you to say something new, it's just poorly designed.
• The "Tooling" Trap: Thinking that learning a weird language is just about learning new syntax. The goal is to learn a new way of thinking.
• The "Glue" Comfort Zone: Staying in the 99.5% because it's easier to find documentation and libraries, even when the problem requires a more fundamental architectural shift.

Connects to

• Domain-Specific Languages (DSLs): This is the practical application of Graham's "Language as a Solution" idea.
• Functional Programming: Many of the "weird" languages Graham implies (like Lisp) are foundational to functional programming.

If you remember only three things

• 99.5% of programming is "glue"; the other 0.5% is where the real innovation happens.
• "Weird" languages are tools for expressing things that are impossible in popular languages.
• Learning to say something new in a language allows you to think something new about a problem.

Internalize it

• Reflection questions

  • What is the "glue" I am currently using to solve problems, and is there a more elegant way to express the core logic?
  • If I had to write a custom language to solve my current hardest problem, what would that language's "grammar" look like?
  • Which "weird" languages have I avoided because they were difficult, and what unique expressions am I missing by avoiding them?

• Flashcards Q: What is the 99.5% of programming according to Graham? A: Gluing together calls to library functions. Q: Why are "weird" languages considered "good"? A: Because their weirdness implies a way of programming that goes beyond simple glue-work. Q: What is the "Intersection of Popularity"? A: The area where all popular languages are equally capable of glue-work. Q: What is the ultimate benefit of learning a weird language? A: Learning how to "say" things you couldn't say before, which allows you to "think" things you couldn't think before. Q: How does Graham suggest solving problems of a specific type? A: By first writing a language for problems of that type, and then writing your specific application in it.

Fidelity note

This summary is grounded in the provided text. Because the original text is a very short essay (approx. 250 words), the summary focuses on the logical implications of Graham's arguments rather than a wide breadth of external topics. The "Common Pitfalls" and "Connects to" sections are derived from the logical conclusions of his argument regarding the "Glue" vs. "Core" distinction.