Larry Wall

> The whole idea of representing UI interactions by changes to a document model is absurd.

Citations needed. Works on my & most machines.

The protesting against the DOM is so endless, but golly gee willikers it sure looks a heckuva lot like a Android Layout xml or any of a hundred other widget tree systems. It's a tree of stuff, like every other UI paradigm. All in all, the DOM makes incredibly little impact, one way or another, on UI design. But heavens is it amazing for the user that there is a declarative document, that there is a common interchange, & not just gooping mounds of code that resist user scripting & user agency.

DOM is a pretty powerful flexible system that, frankly, does much better & has a much harder job than native apps. Native apps rarely do a good job supporting a variety of sizes/zooms, are minimally reactive, where-as the web is incredibly flexible.

> Then it all went in the garbage because it all had to go "on the web".

Citation needed. Did it?

What other UI systems give users any where as much agency or power? What alternate systems give users any agency or power? Or to your bias, what was the halycon wonderful UI world developers frolicked in before?

I feel like the negative voices on this are extremely persistent, but it's entirely unclear to me what UI paradigm is in any way even in the least bit better. They all seem a bit like soupy messes. None of them are remotely good for culture & society at large except the DOM, for none of them are…

Reposting my old comment https://news.ycombinator.com/item?id=10774245 :

> People seem to have forgotten that when Perl evolved from being a better AWK to the paradigm example of the modern "scripting language", Larry Wall explicitly described this as a rejection of the Unix small-tools philosophy. http://www.linux-mag.com/id/322/ ("But Perl was actually much more countercultural than you might think. It was intended to subvert the Unix philosophy. More specifically, it was intended to subvert that part of Unix philosophy that
said that every tool should do only one thing and do that one thing well.") http://www.wall.org/~larry/pm.html The fact that getting things done with a Perlesque scripting language is now seen as the height of purist Unix propriety only shows how far gone the original Unix ideal now is. But moving to the scripting-glue model doesn't really get rid of small tools that endeavour to do one thing well, it just reimplements them inside the scripting-language universe as functions/objects, though with a more expressive and less burdensome common language that makes it easier for them to stay small while being correct and effective. The more expressive their shared language, the smaller [the individual tools in] a set of tools can be.

>> Text just isn't a great medium for IPC.

> Yes, in retrospect Unix's determination to know about nothing but binary or plaintext blobs and streams looks like an adolescent rebellion against the (apparently - I haven't used…

Thanks for your moderation! I'll just add that I generally love Hacker News, and I wish I knew a more constructive way to express my feeling here. (By the way, I think it's an interesting approach of MetaFilter to have a "meta" forum for meta-discussions like this one...)

Larry Wall gave a state of the onion speech about Perl as a "postmodern" language... which means something like, its guiding principles aren't only classical or modernist... it doesn't just aim for simplicity, purity, elegance, unity, etc... instead, it includes some very different values, like plurality, camp, fun, "just weird enough"-ness, "ha ha only serious"... some quotes:

http://www.wall.org/~larry/pm.html

> I combined these cool features [from all kinds of other languages] in a way that makes sense to me as a postmodern linguist, not in a way that makes sense to the typical Modernistic computer scientist. Recall that the essence of Modernism is to take one cool idea and drive it into the ground.

> Well...Perl does one thing, and does it well. What it does well is to integrate all its features into one language. More importantly, it does this without making them all look like each other. Ducts shouldn't look like girders, and girders shouldn't look like ducts. Neither of those should look like water pipes, and it's really important that water pipes not look like sewer pipes. Or smell like sewer pipes. Modernism says that we should make all these things look the same (and preferably invisible).…

Humans resolve a lot of the complexity intuitively and unconsciously. It is not an inherently bad way to handle it, just incompatible with current programming paradigms. This is not to discount the value of clear explicit thinking in humans, it is just to say that programming would benefit a lot from ability to apply common sense to mundane things.

For some dramatic evidence that imprecise is better and it really works, look at the success of Google and the non-delivery of the Semantic Web. Google's approach is probably best explained by Peter Norvig in his "Theorizing from Data" lecture:

http://www.youtube.com/watch?v=nU8DcBF-qo4

State of the art in natural language processing is achieved with statistical inference, not building precise linguistic models. See e.g. Marti Hearst's text here:

http://www.edge.org/q2008/q08_7.html

Back to programming languages, I believe that a lot of the Ruby/Rails success is due to mimicking natural language in DSLs. Rails goes as far as using pluralization. DSLs bring convenience at the price of less understanding: people tend to try using them intuitively, without understanding precisely what happens, much more so than they do with libraries/frameworks.

Perl, similarly, was created with linguistic principles in mind:

http://www.wall.org/~larry/natural.html

It is by no means conclusive evidence, but I believe there is an underlying trend.

For the rationale behind it, read this article by Larry Wall ... http://www.wall.org/~larry/pm.html (really, it's one of the best language-related essays around).

Contrast with Python, where "There should be
one - and preferably only one - obvious way to
do it".

As a Python developer myself, I call that bullshit ... how about 2 urllibs in the standard library, both broken and a dozen or so XML parsers and I still have to install PyQuery to remain sane.

Also, its one obvious way to do it also breaks down in the language itself, like there's still a difference between old-style and new-style classes. And because the language does not have anonymous code-blocks (something which Perl has), the language designers added a bunch of features to take care of certain use-cases, features which are not orthogonal, like lambda expressions, foreach blocks, with blocks, iterators AND decorators, all of which could have been avoided by adding just a simple feature.

If you ever try building a simple DSL, something that modifies a class at runtime, you'll have about a dozen or so techniques to use, but none of them as beautiful as ActiveRecord ... which relies on the fact that a class block in ruby is just syntactic sugar for opening a class context with define_class and passing it a code block.

I watched https://youtube.com/watch?v=PfH8IG7Awk0 a few months ago, I believe he lays out his interpretation in it. Afterwards I was inspired to go reread one of my favorite programming language essays, Perl the first postmodern computer language: http://www.wall.org/~larry/pm.html

It's still great to read but rereading I noticed at the core the same oppression narrative that seems to appear out of all postmodern discourse at some point and which JBP associates with Marxism. Here the programmer is oppressed by stuck up programming languages, Perl reverses the roles and is happy to be like a butler/slave. Which is fine for a programming language, but offers problems when reversing the oppressor/oppressed roles is the only solution you can think of, the only interpretation you wish to dwell on however flimsy the interpretation is (which seems to be where postmodernism went wrong / taken over by Marxists), and each side involves real people.