Winestock Webdesign

See also: The Lisp Curse: <http://www.winestockwebdesign.com/Essays/Lisp_Curse.html#main>, which is a followup and commentary to this article.

> It is kind of cyclical then is not? > By that I mean computers used to be shared and to log into it through a terminal. > Then the PC came around. > Then about 15 years ago Cloud computing became the rage (really an extension or more sophisticated system than the first time shared computers) There's a really neat article called "The Eternal Mainframe"[1] that you might be interested. It explores this idea in greater depth. --- 1. http://www.winestockwebdesign.com/Essays/Eternal_Mainframe.html

You're most welcome! You'll want for nothing but the great thing about lisp, in my opinion, is that it's /so/ easy to create. A good article on this is The Lisp Curse[0], which argues that its power is a bad thing as it prevents communities from forming but as a developer, I want to use the best tools available. If that results in me, as a business owner, requiring less people then that's a win to me. 0: http://www.winestockwebdesign.com/Essays/Lisp_Curse.html

The best answer I've seen is the Lisp Curse. It's basically the idea that Lisp is so flexible that every project becomes its own DSL / idiomatic version of Lisp. Imagine what's being discussed here, except that every programmer actually has the power to just make the change rather than have to submit it to the central Rust team for consideration and eventual implementation. http://winestockwebdesign.com/Essays/Lisp_Curse.html

Here's my site: http://www.winestockwebdesign.com/ It used to be in AngularJS, now it's vanilla HTML & CSS. Mostly typography with just a little bit of animation.

Continued: Churn is further compounded by the Lisp Curse; an individual hacker can scratch his itch in Javascript all by himself and then stick it on github, the other three 1995 langs (Java/Ruby/Python) never quite reached this level of empowerment of individuals. That's great but also means an explosion of activity from smart inexperienced hackers who don't quite have a full understanding of the problem they are trying to solve because they are just one person. And when the problem is I/O that's a recipe for going in circles. http://winestockwebdesign.com/Essays/Lisp_Curse.html

Similar to the "The Lisp Curse": http://winestockwebdesign.com/Essays/Lisp_Curse.html Every project has friction between members, disagreements, conflicts over style and philosophy. These social problems are counter-acted by the fact that no large project can be accomplished otherwise. "We must all hang together, or we will all hang separately." But the expressiveness of Lisp makes this countervailing force much weaker; one can always start one's own project. Thus, individual hackers decide that the trouble isn't worth it. So they either quit the project, or don't join the project to begin with. This is the Lisp Curse.

> The only consistent explanation I've seen that it is about 'easy'. The other languages have tools to make them easy, easy IDE's, the languages 'solve' one 'thing' and using them for that 'one thing' is easier to than building your own in LISP. I have thought something similar, perhaps with a bit more emphasis on network effects and initial luck of popularity, but the same idea. Then about a week ago, I was one of the lucky 10,000[0] that learned about The Lisp Curse[1]. It's as old as the hills, but I hadn't come across anything like it before. I think it better explains the reason "the best languages don't get adopted" than the above. The TL;DR is with unconstrained coding power comes dispersion. This dilutes solutions across equally optimal candidates instead of consolidation on a single (arbitrary) optimal solution. [0] https://xkcd.com/1053/ [1] http://winestockwebdesign.com/Essays/Lisp_Curse.html

Building a community around lisp is tricky. While there are many criticisms to this article [1], there are some elements of the "Lisp Curse" which is true - each programmer tends to rewrite his/her own libraries and so a collaborative framework seldom emerges even while many programmers may work in the same domain. This can be a disadvantage in a domain like the natural sciences where deep collaborations are necessary. Furthermore, the disconnect with traditional mathematical syntax has also turned off many users. There was a predecessor to R called Lisp-Stat [2] which never achieved the acceptance that S/R did, and the Lisp-based syntax of Lisp-Stat was cited as one of the reasons. Following the example of a high-profile Lisp supporter like Peter Norvig who accepted Python as a "Lispy" alternative early on, I think there are a lot of us who have come to accept Python as a necessary compromise. While Python is not homoiconic, functional programming is encouraged through its libraries rather than its core language definition, and the power of macros are missing, the inherent popularity and all the benefits that come with it is tough to beat. [1] http://winestockwebdesign.com/Essays/Lisp_Curse.html [2] http://homepage.divms.uiowa.edu/~luke/xls/xlsinfo/xlsinfo.html

I'll cons this onto my list of reasons why Lisp "failed". Other explanations are: Worse is Better: https://www.jwz.org/doc/worse-is-better.html The Bipolar Lisp Programmer: https://groups.google.com/forum/#!topic/comp.lang.lisp/eicqvm3GXiE The Lisp Curse: http://winestockwebdesign.com/Essays/Lisp_Curse.html Where Lisp Fails: http://www.loper-os.org/?p=69 Lisp is still my language of choice. I'm more productive in it than other languages (C, Java), not because I know the other languages less well, but because they're less expressive. So, for me, Lisp fixes the world. Why aren't people using it? There are three things often missed. (1) People's choice of programming languages perhaps isn't as rational as they might like to believe. There's a large amount of personal taste involved. For a personal project, that's no barrier, you can use your favourite language, but if you're working with a dozen other people, Lisp is unlikely to be adopted because more people on the team will prefer Java, C++, or Python. Multiply over all the commercial projects and you can see why you can't build a career around Lisp programming. (2) There are accidents of history. When DEC decided to discontinue the PDP-10, the days of the hacker community built around it were numbered. Those involved then went on to build Lisp machines, but they were undercut by cheaper, commodity hardware which ran Unix. Then, the AI winter arrived. It was bad for Lisp, but Prolog fared far…

Looking for a feel for Shen? A Strange Loop talk by @deech (40minutes): Shen: A Sufficiently Advanced Lisp. https://www.youtube.com/watch?v=lMcRBdSdO_U An essay: http://www.winestockwebdesign.com/Essays/Lisp_Curse.html It's insightful and readable and it links to several articles new Shen users would be interested in[0]. It was written before Shen, so it talks about Shen's predecessor, Qi. This article and the Bipolar Lisp Programmer by Mark Tarver (creator of Shen) made me feel not so weird for not "getting" UNIX, and helped me get excited about lisp. I'm looking to use Shen or another highly cross-platform functional language for my next project. Application logic in Shen with type-checking. web code using some framework. [0] Wow I'm re-skimming it now: it has Stanislav, James Gosling, buncha Smalltalk, Rob Pike's "Systems Research is Dead" and a lot more. This is actually a good overview of ways to be disillusioned with programming. IMO disillusionment by knowing our historical failures is an antidote to the hype-machine.

Lisp's macro system is so powerful that it actually turned out to be the 'curse' of Lisp: http://www.winestockwebdesign.com/Essays/Lisp_Curse.html However I wouldn't call it "curse" but merely the truth that Lisp programmers need a lot of self discipline to write maintainable code. Lisp was one of the first languages I learned at university (also Pascal and Ada). Afterwards I learned almost every other new programming language. Lisp and the Scheme dialects are still the most powerful languages of all, to this day. People who are intimidated by such a raw power should take a look at Nim (nim-lang.org). It takes the best of several modern languages and it also has an amazingly convenient and powerful macro system. For instance: template repeat * (body: stmt): stmt {.immediate.} = block: while (true): body template until * (cond: expr): stmt {.immediate.} = block: if cond: break var i=0 repeat: echo i i += 1 until i==7

The core thesis of this essay is reminiscent of the Lisp Curse [1] / Bipolar Lisp Programmer [2]. It's been a few years since I read these, but if I recall the argument there, it was that Lisp makes it so easy to build stuff and scratch exactly your own itch, that there's no real strong push for lisp programmers to come together and collaborate to build non-trivial and general purpose artifacts. And that is why the landscape of public lisp software is poorer as a result, compared to languages which demand much more effort to get anything substantial done. Armin seems to be making a very similar point about AI coding. [1] https://www.winestockwebdesign.com/Essays/Lisp_Curse.html [2] https://www.marktarver.com/bipolar.html

The lisp curse: https://www.winestockwebdesign.com/Essays/Lisp_Curse.html

The Lisp Curse: http://winestockwebdesign.com/Essays/Lisp_Curse.html

Yeah, but there's always a cultural struggle to prevent everyone from using their own incomprehensible DSL. See "The Lisp Curse" [1]. Even vanilla Haskell (without macros, i.e. without Template Haskell) takes it too far by allowing to define arbitrary custom operators with arbirtary associativity and precedence. Many Haskell libraries are an incomprehensible soup of symbols instead of regular functions with readable names. Rust does pretty well so far. Macros are used appropriately in the ecosystem. [1] http://www.winestockwebdesign.com/Essays/Lisp_Curse.html

Also http://www.winestockwebdesign.com/Essays/Eternal_Mainframe.html

Once you get far enough to need external dependencies, do you use your work as a library in another language or rewrite it? http://www.winestockwebdesign.com/Essays/Lisp_Curse.html

> If Lisp is so good, why isn’t its use more widespread? The Lisp Curse: http://winestockwebdesign.com/Essays/Lisp_Curse.html

I have been acquainted with Clojure for a few years now. Haven't been able to 'break in' despite several attempts. My main conclusion is this: the language/workflow make developers way more productive compared to other modern stacks (I do Python/Ruby/TS on my day to day). The biggest, unsolved problem is http://www.winestockwebdesign.com/Essays/Lisp_Curse.html tl;dr It is so easy to implement things in Lisp so you end up with a myriad of half-baked solutions and no long-term support of dependencies.

Perl lost popularity when people were using windows, learnt programming with java, were scared by unix idioms, implicity, regexps, contexts and concepts like anonymous blocks you can map/filter with. nowadays everyone finally think those features are cool (maybe even C23 will have lambdas) so perl wouldn't have lost popularity. I'm still waiting for 1 other interpreted language to have something as convenient as the CPAN ecosystem. However I see one similarity between C++ and Perl: for decades, they evolved a lot from there ecosystems and nowadays, both C++ and Perl could be difficult to learn just because you can't figure out what module to use to get the job done. Also Perl suffers the lisp curse http://winestockwebdesign.com/Essays/Lisp_Curse.html (I don't know about C++).

You're not the only one, "The Lisp Curse"[1] essentially says the same thing (but spends a lot more time praising/criticizing the "lisp hacker"). > The expressive power of Lisp has drawbacks. There is no such thing as a free lunch. > - The Lisp Curse [1]: http://winestockwebdesign.com/Essays/Lisp_Curse.html

I'm not referencing the market share. I'm referring to Lisp Curse. http://www.winestockwebdesign.com/Essays/Lisp_Curse.html In summary: Because Lisp was easy to fork, any time two nerds disagreed it was forked. And because they weren't working on same database you got Lisps with patchworks of functionality/bugs that each on their own couldn't compare to more or less monolith language like C/C++ or Java. Same dynamic in Linux land. So instead of having 1000 developers on one codebase we have 100 on ten different DE, windowing system, etc. Rather than having one sound system we have a dozen... It doesn't work on PulseAudio, try OpenSound, no wait OSSBlasterMaster...

The Lisp Curse http://www.winestockwebdesign.com/Essays/Lisp_Curse.html

I've now had time to Google, it's The curse of LISP. http://www.winestockwebdesign.com/Essays/Lisp_Curse.html

Obviously what you say is true, but there is a cultural element to this. Java has a library ecosystem that is stable but not ideological, unlike golang. I think of golang as the opposite of "The Curse of Lisp" [1], wherein its so standard that it can't fit the evolutionary cracks as well as a less opinionated framework. The ugliness of Java has been its strength. Whether it's Hotspot or ZGC or arch support or whatever, the JVM bytecode and rather limited capabilities of the language forced more focus on the objective quality of the artifacts of the language rather than the language itself. A lot of those artifacts continue becoming more impressive over time. [1] http://www.winestockwebdesign.com/Essays/Lisp_Curse.html

Haskell would conquer the world if it had a C-like DSL with C-like semantics. Think do notation with a state monad, on steroids. Thing is, there's already a dozen homespun libraries of various kinds doing just that. As an extreme example (mostly just to prove the point): http://kormacode.blogspot.com/2011/11/c-style-haskell_10.html Which leads me to perhaps the real thing functional languages need. A standard way of doing things. Standard patterns for standard problems, familiar and normal, which the average programmer can recognize. This is related to the Lisp curse: > Lisp is so powerful that problems which are technical issues in other programming languages are social issues in Lisp. http://www.winestockwebdesign.com/Essays/Lisp_Curse.html Most functional languages suffer from this to some degree.

Yor sentiment is beautifully captured in the essay "The Eternal Mainframe" [1] by Rudolf Winestock. It gets reposted every year or so here on HN. [1] http://www.winestockwebdesign.com/Essays/Eternal_Mainframe.html (2013)

Main issue is, D is suffering from "Lisp curse" [0]. Read the Lisp curse article, but exchange Lisp for D and you'll have a good idea of the problem. D is very similar to Lisp in many aspects. It's a powerful language which allows you to create your own minilanguage within a language. In Lisp, you'd do it with macros, in D you can use templates. This makes it a secret weapon which appeals to lone wolf programmers, but it makes it harder to interact within a wider community. Similar with the language features. D allows multiple paradigms, as a result, many libraries don't interact well together. Some people code in OOP fashion, some people refuse to use the garbage collector, some people even reject the entire runtime (betterC_mode). [0] http://www.winestockwebdesign.com/Essays/Lisp_Curse.html