Larry Wall

Incidentally, as a color, it's one of Larry Wall's favorites. http://www.wall.org/~larry/

Larry Wall (creator of Perl) has a really long (but fantastic) speech on modernism and post-modernism that I found helpful. It is transcribed somewhere and worth the read. Edit: http://www.wall.org/~larry/pm.html

I also really liked the follow up on the three virtues, in the 2nd State of the Onion (http://www.wall.org/~larry/onion/onion.html) > Most of you are familiar with the virtues of a programmer. There are three, of course: laziness, impatience, and hubris. > These are virtues of passion. They are not, however, virtues of community. The virtues of community sound like their opposites: diligence, patience, and humility. > They're not really opposites, because you can do them all at the same time. It's another matter of perspective. These are the virtues that have brought us this far. These are the virtues that will carry our community into the future, if we do not abandon them.

the man is a legend. Perl was awesome when it first came out. Its time has passed but you can see Perl's influence in many things we use and take for granted today. favorite writing: http://www.wall.org/~larry/pm.html

or the worst. As Larry Wall said: "The potential for greater good goes right along with the potential for greater evil."[1] [1]: http://www.wall.org/~larry/pm.html PS. I always wanted to quote this :-)

> 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…

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.

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).…

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.

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.

Thanks for the Austral spec link! Programming languages come and go but I find it deeply interesting when language designers lay out the rationale behind possibly outlandish decisions in their programming languages. Case in point, Larry Wall and Perl-y languages [0] [0] http://www.wall.org/~larry/natural.html

well the answer is easy, it's all on Larry Wall's homepage: http://www.wall.org/~larry/

Don't forget Larry Wall's page: http://www.wall.org/~larry/ :-)

I'm not defending the sigils because they are terrible, but the reason you can't just get rid of them is that they are actually used. For instance: my @arr = ("Larry", "Moe", "Curly"); my $len = @arr; will store 3 in $len. Application codebases and libraries make use of this kind of thing everywhere. You can find some of the reasoning why in interesting essays like this: http://www.wall.org/~larry/natural.html Larry Wall was trying to incorporate some natural language features in Perl, unsuccessfully in this case but I would say it went very well in others.

It says Larry Wall isn't working on Perl anymore. When did that happen? It looks like the Perl6 thing was announced in 2000 and around 2010 Larry Wall deleted the Perl page from his blog (it's been a 404 link ever since) - https://web.archive.org/web/20100214124540/http://www.wall.org/~larry/… - http://www.wall.org/~larry/perl.html That butterfly was the worst. Perl would have been better served having an animal like the honeybadger as its logo.

>>PHP also inherits shell's here doc syntax, e.g. <<EOF . Not sure if Perl has that. It does. >>It kind of annoys me that they all require $ on the left Larry Wall says he went that direction to make namespace clashing between $dog, @dog, %dog, and "sub dog {}" (scalar, array, hashtable, function) a non-issue. http://www.wall.org/~larry/natural.html ("Disambiguation")

Natural Language Principles in Perl (by Larry Wall): http://www.wall.org/~larry/natural.html

Larry’s Perl page is a bit telling: http://www.wall.org/~larry/perl.html Perl 6 is still the future of Perl? https://www.perl6.org

Yup! http://www.wall.org/~larry/cornea.html It's actually a really cool read - I wish he had more stuff posted on his blog to read :(

What's with the > Getting paid for it! On his geek code explanation? http://www.wall.org/~larry/ungeek.html

There's a long article from Larry Wall (Perl's inventor) on Perl being Postmodern. It was probably the first time I saw it explained as such. An interesting talk even if you don't like Perl much: http://wall.org/~larry/pm.html

Larry Wall (creator of Perl) was ahead of the curve on brutalist design :) http://www.wall.org/~larry/

Coming from the Perl 6 project, it feels to me like design is a major part of modern computer languages, like Perl 6 and ES6+. Perl 6 started with its design documents[0] -- the apocalypses led to the exegeses, which finally settled into a synopsis. The Perl 6 language itself is not any of these: The test suite defines the language, but the reasons they are the way they are came first. It has design features like hyperoperators to make parallel code easier to write -- which of course should encourage people to write parallel code. Perl 5 is explicitly a postmodern language[1], and Perl 6 is the same but more. From my point of view, Python looks like it has a strong modernist philosophy. So I'm not really getting where OP is coming from. [0]: https://design.perl6.org [1]: http://www.wall.org/~larry/pm.html

Perl is explicitly postmodern. Here's Larry Wall explaining it: http://www.wall.org/~larry/pm.html

I realize that many projects haven't made the switch, and in some cases they have good reasons to be cautious. And I realize that many programmers aren't familiar with the various changes, even after five (or more) years to catch up. But that doesn't change the age of the standard, or the fact that C++14 was published, and the Committee is finishing up C++17. At some point it's silly to call C++11 "new." "Unfamiliar," sure, but not "new." It reminds me of Larry Wall's talk ( http://www.wall.org/~larry/pm.html ) "Do you know when New College was founded. Any guesses? New College was new in 1379."

The simple theory I use for explaining Perl preference is that it correlates to your preference and tolerance of postmodernism in general. http://www.wall.org/~larry/pm.html is a good elaboration on the postmodernism of Perl, I think.

For the ease of others (your link is broken): http://www.wall.org/~larry/

prodigious intellect and a childhood hero of mine. Unfortunately his contribution to web design rarely gets mentioned (http://www.wall.org/~larry/); no bootstrap--incredible.

I found this talk rather illuminating; I try to re-read it at least every couple years. http://www.wall.org/~larry/pm.html It's largely about Perl (delivered at a Linux conference), but I believe it will give you some material to consider while exploring how postmodernism applies to technology.