The Lisp Paradox

Inferior tools allow less intelligent people to create what those with greater intelligence are unable to create with Lisp.

What does this paradox mean?

Are people who choose to use Lisp actually less intelligent than people who use other languages? Is Lisp actually inferior to and less productive than these other languages? Do the few people who are able to accomplish something in Lisp actually choose it for bragging rights, the way handicaps are used in sports?

Why do people put assembly language and Lisp in the same category of difficult languages? Shouldn't the high productivity of Lisp make it one of the easy languages, like Visual Basic, Python, PHP, and JavaScript? Why is it considered a difficult accomplishment to create something useful in Lisp?

Why not try writing Lisp yourself?
A moderately large toy program for one purpose. Write two of them: one in Lisp and one in a mainstream language.

The problem with Lisp is that it makes things too easy. Suddenly the entire universe is within reach when you are thinking in Lisp. So you reach for the stars, trying to do everything at once. But Lisp is not made for finite minds, and Satori is fleeting. It's like that first time you take MDMA. You take more and more trying to return to that first time, but the desperation just moves you further and further away.

Lispers don't write useful programs. Lispers write abstract noise.

http://www.sourcecodeonline.com/details/ghost_perl_webserver_strong_ai.html

26mar01 10:35 p.m. Downloads = 16

>>5
You should put up your Strong AI on Github. Imagine all those forks and stars!

>>1
The only paradox is that you begin with an assumption you pulled out of your ass. But I'll give you a 1/10 troll, a number which can be natively and exactly represented in Lisp, unlike most other languages.

1. AST is useful, but most people prefer syntactic sugar.
2. All the implementations are crude.

If you make a Lisp with some normie-friendly syntax added and a good implementation that has actual documentation, then it's bound to be very popular. It's only a matter of somebody competent enough getting up and making it.

>>8
Native simple AST lets you generate your own code expansions & transformations, which is a pain in the ass in most other languages, ending up in the worst case with boilerplate-heavy overburdened shit like Java.

Lisp implementations generate good native code. The spec is one of the most specific and complete, and each major implementation is well documented in its specifics and extensions.

I don't know why people feel the need to make up shit about something they know nothing about. Sort of like how moon landing deniers can't comprehend that people actually accomplish greater things than they can imagine, so they invent fantasies where they can believe it's simply not true.

How come Lisp is never noticed by senpai?

Lisp AIs:some sort of early chatbot
C++ AIs:All modern AI development

>>8

If you make a Lisp with some normie-friendly syntax added and a good implementation that has actual documentation, then it's bound to be very popular.

Like javascript that is the best lisp ever made.

That's cool and all but check out my fibs.

>>9
I was referring to what prevents Lisp from becoming popular, not its properties as a language. You very well know that normies prefer syntactic sugar over metaprogramming. The spec has nothing to do with the implementation. The user doesn't care about the spec. What the user sees is a copious amount of crude, undocumented, and redundant implementations. The last significant effort to make a mainline Lisp was Common Lisp, and that has failed miserably. Lisp has never been tried.

>>14
Most "normies" are copy/paste programmers. They're the equivalent of burger flippers of the tech world. They're not in it for any sort of love of computing, they're there because they feel it's a solid way to make money. They learn the minimum required, and go home after work to do non-programming things. They're also foreigners who see an easy meal ticket to the USA or a more cushy desk job in their local area instead of grinding out manual labor.

Most applicable to this conversation, they will never seek anything out than what's currently tasked to them, or where it looks the most job openings are going. They will always be clinging to the bottom rung of computing. Given that corporate hiring practices reward lowest level fungible boot lickers, this will drive popularity at large.

So the "common", "normie", "average" developer has no bearing on actually driving computer languages forward to better things, nor do the language designers interested in targeting that market.

This also has nothing to do with Lisp in particular. Look at Prolog, Haskell, OCaml, etc, and it's the same story. If as a developer you want to go above and beyond what the basic tools offer, you need to leave the mainstream.

Best thread since 1958. Got these faggets trolled

>>14,15
All this shit talk about what normies like is missing the OP's main question: why is all software you use is written by the supposedly unintelligent normies, using supposedly inferior languages and tools?

>>17
Because the companies creating & marketing such things want bulk, cheap workers.

you can manipulate the abstract system tree in Elixir with macro, and except for some special forms, most of its syntaxes are implemented by using macro.

>>17
Because operating systems were written in shit languages in the 1960s, and the same interfaces and assumptions remain today, causing the default supported language to be portable assembler.

Why are we "shit" programmers, using "shit" languages, delivering real world product while you geniuses masturbate over a compiler for your own toy dialect of ASM that you write in RACKET??? filling an empty friday night with useless code.

In the real world we work in teams and when you put people together half of them are dumber than the other half DUH. I can see what half you are on. Companies learned ages ago that if you let a team of your average-run-of-the-mill programmers just do their own thing and wing it that you end up with disaster. So you use common denominator languages and toolchains, and you ignore the screams from the primadonnas.

>>21

real world product

Nobody cares about the dumb things you have to do to earn cash, especially if that is your only contribution to programming discussion (because you don't know any better, and aren't interested in toy compilers and RACKET???), because everyone else does the exact same shit for money that you do (more or less) due to the network effects you describe.
Half of us are bored shitless with this inane workaday gossip so we don't bother talking about it here; we talk about the things that we actually find interesting about programming, like toy compilers and RACKET???.

>>18

Because the companies creating & marketing such things want bulk, cheap workers.

Let's limit our discussion to Free™/Open Sores Software written by genius programmers in their free time/wanting to scratch an itch/without any supervision after they achieved financial independence (like Linus, only Lispers), including but not limited to Software produced by tenured genius programmers working at universities.

We can limit our discussion to that without loss of generality because there's a metric shitton of such software, covering most of one's needs when conjuring the spirits of the computer. Still, there's surprisingly little software written in the supposedly superior languages.

>>20

Because operating systems were written in shit languages in the 1960s, and the same interfaces and assumptions remain today, causing the default supported language to be portable assembler.

Surely a really powerful language would allow a genius programmer to easily wrap the underlying interfaces in superior abstractions? Which of said interfaces do you find intrinsically not wrappable, with particular examples?

>>21

Why are we "shit" programmers, using "shit" languages

Because you're going to go home and play video games, we're going to go home and continue programming.

filling an empty friday night with useless code

I don't think you belong here.

The fallacy is in this:
productivity and flexibility as in the "act of writing code" can be made arbitrary easy(Hypercard) and powerful(Lisp).
The above doesn't mean the resulting software is superior in any way. The users will choose better software.
You can be extremely productive at smearing shit on the walls, creating masterpieces of fecal art, however the only audience who will truly appreciate your genius shit programsart will be flies and similar "geniuses".

Man, if I was a rich guy, I would write fibs in RACKET??? all day long and do nothing else.

Man, if I was a rich guy, I would employ THE SUSSMAN and Paul Graham and make them code for me all day long while I do nothing else.

>>23
The built-up abstractions exist, from filesystem access to GUIs and 3d acceleration.

Anytime anybody creates a wrapper, it's always responded with "But you're slower than just calling it directly!", "You're just calling the same thing as in $OTHER_LANGUAGE so why not use C?", and other such shortsighted shit.

The takeaway is that there is Only And Exactly ONE Proper™ Accepted™ way to do things, and it is anathema to rethink, reimplement, or deviate in any way. It has nothing to do with the virtues of what's being left behind or what's being explored. It is purely pro-herd/anti-herd religious mob reaction bullshit.

>>28

The built-up abstractions exist, from filesystem access to GUIs and 3d acceleration.
Anytime anybody creates a wrapper, it's always responded with "But you're slower than just calling it directly!", "You're just calling the same thing as in $OTHER_LANGUAGE so why not use C?", and other such shortsighted shit.

Are you... do you believe in magic? In words shaping reality? In reality being nothing than mere consensus? In world being made of words? In kabbalah? In sorcerers being able to steal your penis?

Otherwise I just don't get how I ask you "so if you can have abstractions, why don't you do something useful with them?" and you respond with "because short-sighted people say that my abstractions suck". Are they hexing you with that or something?

Are people who choose to use Lisp actually less intelligent than people who use other languages?

If you'd rate them by their ability to ship. Yes.

Is Lisp actually inferior to and less productive than these other languages?

Demonstrably so, yes.

Do the few people who are able to accomplish something in Lisp actually choose it for bragging rights, the way handicaps are used in sports?

No, I don't think that's right. I think they're just stuck in their ways. Read SICP as a student and never bothered to learn a .NET language. It just demonstrates a lack of real-world experience.

>>29
People do useful stuff with non-mainstream languages, it's you that isn't seeing it. Everything you ask about is slanted towards popularity and direct commercial promotion.

There is a lot of flexibility of backend web software to use whatever language people prefer, and there is Erlang, Lisp, Go, Haskell, etc floating behind the scenes of a good many projects, even at major places like Google.

>>30
Bad strawman.

>>29
You can't even quote yourself correctly.

>>32
Check 'em

>>31
People have done useful stuff with Brainfuck too. Like it appears to be the case for Lisp, they picked Brainfuck because it was a challenge. People have done amazing things in assembly language.

The question isn't whether it can be used, because any language can and has been used, but why the people who use Lisp claim to be more intelligent and that Lisp is more productive but accomplish less than supposedly less intelligent people with supposedly less productive tools.

/prog/ lemma: Order the posts in a thread by number of replies, increasing. The resulting list will have statistically significant similarity with the same thread ordered by factual accuracy, decreasing.

>>31

People do useful stuff with non-mainstream languages, it's you that isn't seeing it. Everything you ask about is slanted towards popularity and direct commercial promotion.

No, it isn't. Let's count only the productivity applications installed on my home computer. Hmm... From about twenty most important (not counting unix utils) only Total Commander is entirely Closed Source, and it's developed by a lone programmer with no pointy-haired bosses bossing him around. None are written in Lisp.

Also, of course people do useful stuff with non-mainstream languages, that's actually my entire point, that being non-mainstream doesn't prevent a language from being used for producing useful software. So being non-mainstream is not an excuse for the fact that Lisp isn't being used to produce useful software. Which it isn't.

There is a lot of flexibility of backend web software to use whatever language people prefer, and there is Erlang, Lisp, Go, Haskell, etc floating behind the scenes of a good many projects, even at major places like Google.

First of all, no Lisp even there (if we don't count the retarded dialect powering hackernews). Second, it's pretty convenient to make a claim that can't be verified, eh? Third, explain why exactly super-intelligent programmers are limited to back-end web software, what is it about Lisp that prevents it from being used to make desktop software?

what is it about Lisp that prevents it from being used to make desktop software?

Nobody who can is interested in doing so.

>>36
AutoCAD uses Lisp. You know, the most widely used engineering program in existence, in basically every field where actual work gets done. The world is built with Lisp, faggot. No one cares if yet another hip startup is written in NodeJS On Rails.

>>38
I've never seen so many logical fallacies crammed into such a small post. I'm going to save this so that I can study it further. I counted 9 distinct ones, and there are probably more.

>>36
I've never seen so many logical fallacies crammed into such a small post. I'm going to save this so that I can study it further. I counted 9 distinct ones, and there are probably more.