1. 22

The video of this paper was submitted to Lobsters here.

  1.  

  2. 9

    The video is pretty much my favorite programming talk of all time. Rewatched it several times over the years.

    1. 4

      Can people enthusiastic about this video explain what they think is so great about it? What did you learn from it? It gets basically unanimous rave reviews, while I feel it belabours something for which a short explanation suffices. Sure, it’s entertaining for a bit, but it doesn’t entertain me for long. What am I missing?

      1. 6

        Obviously the structure of the talk is entertaining. But the content is also truly insightful. I think you get more out of the talk if you understand the history surrounding PL design and where Guy Steele fits in.

        You see, he helped design Scheme, which was a notoriously “small”, yet niche and obscure, language. Then he helped design Java, a notoriously “big” language, that achieved massive growth and mainstream popularity. In that swirl you had the same small/large debate happening in the C/C++ community, and in the Lisp/FP community (Scheme, Common Lisp, etc). His talk helps one understand how the same person who helped influence the design of a “minimalist and clean” language like Scheme could also have played a key part in the design of a “large and messy” language like Java. The key point, illustrated through the talk, is that large and messy isn’t so bad, so long as the language can be perpetually extended by the community (like the English language has done over centuries).

        You can also gain more out of the talk if you read up on FP community influences, like SICP.

        1. 2

          So I know these things about Steele. I own a copy of SICP. I am aware (to mention some random things that seem connected) that many languages, as a first step, compile to a smaller core language, making much of the familiar ‘end-user’ syntax syntactic sugar. That language features can be orthogonal or intersecting. That some language features can make some extensions impossible. That you can implement an object system in a Scheme, etc. But I still don’t seem to get it. Perhaps I miss a feeling for how appropriate/timely/illuminating it was in 1998? A sense of historical perspective, because I just didn’t experience it at the time, but are only looking at it from a world in which Steele’s message has been internalized?

        2. 2

          I think people’s fascination with this is caused by the contrast of the simplicity the talk suggests – and the 99% failure rate of languages even following basic bits of this advice.

          1. 1

            99% of all languages are not needed, so fail. The talk is amazing because it points out what we know but don’t understand, how growing a language must work.

            1. 2

              99% of all languages are not needed, so fail.

              That’s not what I meant.

              Regardless of whether a language is needed or not, successful or fails (popularity is largely disconnected from quality), I say there is a huge probability that any given language is a hastily glued-together train-wreck because 99% of the time creators have not spent a single thought about having some coherent, upfront design.

              Language quality is still so incredibly poor–even after decades of people inventing and reinventing stuff–that it doesn’t feel like we have made much progress since the 70ies.

              1. 2

                I think most of the language stuff we need we learned in the 70s. Since then we’ve been trying to make things more and less efficient, at different stages in the process. We have not yet hit on the best combination of the ideas we learned, though there are enough monkeys at typewriters, I’m sure it’s any day now.

                Ultimately, languages don’t matter, just what we can and do do with them. Success is determined by being able to build things with a new language.

                1. 1

                  Language quality has no meaningful relationship with language popularity, so I’m not sure how your comment is related to the topic at hand.

                  1. 2

                    I see language quality as more than the raw quality from a purely theoretical standpoint. I also consider language usability and adoption as part of the quality.

                    1. 1

                      Then I don’t think there is anything to discuss.

                      1. 1

                        I should explain. The problem is quality needs real world considerations. PHP has quality, despite being garbage, because it’s accessible, readily available to users, and a lot of work has been doable due to PHP. To say it lacks all quality because from a theoretical standpoint it does is to be dishonest, and disheartened.

                        1. 3

                          In the early days, PHP had the quality of being several hundred times cheaper to run (via shared hosting).

                          Aside from anything else it did, that aspect drove an immense amount of usage.

                  2. 1

                    Can you give, or point to, examples here? Because I’m not aware of this big a problem.

                    1. 1

                      Just a few examples:

                      • Lack of decoupling between internal representation and outside access: This is why languages force people to manually sprinkle getters and setters, properties etc. all over the place. A completely unnecessary pain.
                      • Generics with <>: There is not a single language in history who has managed to pull this off without introducing terrible hacks, absurd parsing rules and readability issues. Instead of asking the core question of “why do we keep doing this?” we get new languages … using <> for Generics. Despite better options. Because of “familiarity”.
                      • Basic things like equality and comparisons simply don’t work, decades after the problems and solutions are well-understood. Just try the equivalent of List(NaN).contains(NaN) in a few languages and experience the garbage of results. Even languages that get this right sometimes arrive at the result via complete garbage semantics like “we happen to box our double values here, and that means NaN <EQ> NaN returns a different result compared to the unboxed values”. The whole situation is even worse for comparisons … it’s just so bad, that it’s laughable.
                      • Consistency of modifiers: For instance, compare the rules of modifiers for classes and interfaces. It’s a complete mess simply because of shortsightedness, and Java is far from the only language suffering from that.

                      I could probably go on and on, the key point is: Language quality; language popularity – pick one.

            2. 2

              My favorite PL talk of all time as well!