[braythwayt]

Of course SICP is brilliant in Scheme. But hello? There is no such thing as a “blub language.” Your comment misrepresents the entire point of the original PG essay!

The point is that givens some fictional language called “Blub” for the sake of the essay, some programmers believe that their language has everything that could possibly be useful, productive, expressive, &c.

But PG’s contention that languages exist on a continuum of power (a gross oversimplification), and when a programmer believes that their “Blub” is as powerful as possible, they have closed their mind to more powerful/useful/expressive ideas.

But that’s as true of Scheme as it is of JS: If someone believes that LISP was the zenith of programming, and everything else since then has just been wankery, if they think we have nothing to learn from Haskell, or Julia, or Joy... Then for them, Scheme is Blub.

Blub is a mindset, not a language. Sure, some communities might be infested with Blub programmers, but nevertheless, languages themselves are not Blub.

Now, if someone says that SICP in JS proves that Scheme is no better than JS, well... That person has a Blub mindset. But teaching some of the same principles as SICP using JS is not in and of itself the Blub mindset.

Summary:

Blub is a mindset, not a language.

All languages are Blub languages if someone has the Blub mindset.

SICP in JS in-and-of-itself is not Blub.

JS in-and-of-itself is not Blub.

[superdisk]

Considering everything is being shoved into the web paradigm and written in JS even when it's wildly wrong for the job, I think it fits the description perfectly.

[braythwayt]

If you really want a blog post to describe how JavaScript is eating the world, I suggest it isn’t “Beating the Averages” by Paul Graham.

It’s actually “Worse is Better” by Richard Gabriel. I don’t think people are writing JavaScript tooling while saying that JS is just as powerful as Haskell or Lisp. What they’re saying is that its ubiquity is valuable and for their use case, ubiquity and network effects trump productivity and/or “power” however we might want to define them.

[viklove]

> even when it's wildly wrong for the job

Oh, are you the great decider who decrees what we can and can't use certain programming languages for?

[superdisk]

No, but JS certainly wasn't designed for what it's been retooled into doing now. Neither is HTML.

[projektfu]

The nadir is the low point, the antonym of zenith.

[braythwayt]

Thanks!

[austincummings]

> original PG essay

Which essay is that? I'd be interested in reading it.

[iNate2000]

http://www.paulgraham.com/avg.html

[austincummings]

Thanks!

[throwawaybbb]

Simple question: do you know enough lisp to write a self hosting interpreter in it?

People talk up their language until they learn lisp then this happens: https://www.draketo.de/proj/py2guile/

[braythwayt]

"Do you know enough lisp to write a self hosting interpreter in it?"

Short answer: Yes.

Long answer: No!

I learned Lisp and TI-Scheme in the early 80s, and somewhere around then we did some SICP-like stuff in undergrad CS.

I later came upon SICP and worked my way through it, having the usual "Aha!" moments. I thought I knew something about Lisp and Scheme at that point. I built some self-hosted interpreters using the following pattern:

1. Write an interpreter for a minimal subset of Scheme in a host language.

2. Write an interpreter for a more full-featured Scheme in the subset of Scheme.

At some point, I read LiSP [0], and I discovered that what I thought was enlightenment was actually but a hint of the delights to come. The entire book is about teaching programming through the device of building interpreters and compilers.

So my next pattern was something like:

1. Write a minimal Scheme interpreter in a host language.

2. Write a Scheme compiler in Scheme.

3. Bootstrap the compiler by running in in the interpreted Scheme.

4. Now you have a compiled Scheme implementation written in Scheme.

5. Build out more features.

And now, this approach is one of my go-to tools. A few years ago, I was playing with Turing Machines, and I used a "constructive proof" approach: If we want to demonstrate that a Turing machine with tape that has one end is just as powerful as a Turing Machine with a tape that stretches to infinity in both directions, write a compiler from one kind of Turing Machine to the other. And so on and so forth to prove that being able to write an infinite number of different symbols is no more powerful than writing 0s and 1s. Or that a multi-dimensional Langdon's Ant is no more powerful than a Turing Machine...

Interpreters and Compilers are very powerful tools for constructive reasoning.

But the point of the discussion around Scheme for this purpose is how easy it makes writing Interpreters and Compilers. On the one hand... Shrug... Since we can write interpreters and compilers in any language.

On the other hand, a tool that removes a lot of the accidental complexity in writing interpreters and compilers changes the way we think about writing interpreters and compilers, much as parsing text using a language built around pattern matching (like SNOBOL and its descendants) changes the way we think about parsing text.

So... We are probably in deep agreement about the value of SICP in Scheme, and the value of Lisp in general, not just as a language, but as a way of changing the way we approach solving problems.

And as for knowing enough... The truth is, every time I sit down with certain programming ideas, I learn more and realize that what I thought I knew was incomplete.

So in a very real sense, I suspect that no, I don't know nearly as much as I think I know.

---

[0]: Lisp in Small Pieces: https://www.amazon.ca/Lisp-Small-Pieces-Christian-Queinnec/d...

[Dangeranger]

Thank you for writing this up Reginald. I appreciate seeing the journey that someone such as yourself has taken in learning these ideas, and the perspective that it has imparted along the way.

"When we admit we know nothing, then we are free to think anything."

[pjc50]

As a C developer: while I could probably do that given a few months, I've somehow managed 25 years without needing to interpret C? It's cool and all, but in terms of product requirements tends not to be high on the list?

Most languages are vulnerable to contexts where their particular gimmick doesn't work. You probably wouldn't write an interrupt handler in Lisp. You wouldn't write a bootloader in it either (although you might choose Forth, the other fanatic minimalist language). Conversely C gives you no runtime dynamism. Endless people try to write language-to-Verilog converters and are disappointed.

[jessaustin]

Someone who has written so much [0] about functional programming, I would suspect has written an interpreter before.

[0] http://raganwald.com/

[throwawaybbb]

I have written interpreters in python and god help me lex and yacc. The point is that writing one in scheme is so easy you almost think that the language was designed with that in mind, it was in case the sarcasm doesn't get through the text.

[jcora]

Can lisps place arbitrary code in types and formally verify complex properties of stateful systems--all in the same language? Doubt it. Lisp isn't the epitome of power.

[shakna]

... Yes. Of course they can.

Lisp is usually an academic language, which means research into type systems and type safety frequently takes place in it.

ACL2 is a theorum prover written in Common Lisp [0]. And not just a random project either, but something AMD, ARM, IBM, etc. have used.

[0] https://en.wikipedia.org/wiki/ACL2

[jcora]

This is not a practical language with dependent types tho lol

[throwawaybbb]

Yes. That's the point, you will write the dsl to do that in scheme. Then use that to solve the original problem. Abstractions on top of abstractions.

[jcora]

No. You can write a compiler for any language in Scheme, but it's disingenuous to say that Scheme has that language's features. There are many languages with way more powerful features than Scheme if you're comparing type systems.

[iLemming]

Checkout Little Typer and Clojure.Spec.

> Lisp isn't the epitome of power.

Lisp is the epitome of simplicity. If the foundations based on simplicity you can do very powerful things.

[braythwayt]

Lisp in general is not the epitome of simplicity. Lisp-2s like Common Lisp add some cognitive load for those used to simpler languages (although Lisp-2s have their advantages).

And of course, Lisps that include meta-object protocols (Flavours, Common Lisp again, &c.) deliver power, very elegantly, but for people unfamiliar with them, there is a learning curve to climb.

[iLemming]

You're mistaking Lisp for a programming language. Which Lisp is not. Lisp is an idea (or rather a set of ideas), based on which different PLs can be implemented.

[lispm]

McCarthy not only had an idea, he and his team a specific programming language. It even had a manual.

This is the Lisp I manual:

http://bitsavers.org/pdf/mit/rle_lisp/LISP_I_Programmers_Man...

[neonate]

He said Lisps and Lisp-2s, so obviously knows this.