Lisp. Lisp is the only language

Why there are other programming languages besides Lisp? With Lisp's macro system you can create any language you need ever. Small, big, finely tuned for your task. Supporting other languages means opposing progress and delaying the inevitable future. There should be only one language and myriad languages at the same time. The one language is Lisp.

Prime Number GET

<--- "Answer to the Ultimate Question of Life, the Universe, and Everything" GET

>>39
are you autism honest question

It's funny how only Lispfags are giving non-trolling, valid arguments.

>>44
fags
Back to ``yo'ure faggot is anus'', please.

>>44
.+fags but a valid argument but spaced sage

I don't know how to react to this, you can stay.

>>44,46
samefag

>>47
You go back to /b/.

complain about trolling in prog, then dedicate 100% of posts to talking about how great a useless language is.

typical LISP fanboy

>>49
>useless language
>the universe was programmed in it

Troll harder, troll!

>>50
no sage
improper quote
amauter-level BBCODE

2/10
You would achive 1 if you will use mailto:noko next time

>>21
For the same reason Forth is dead: the language gives too much freedom.

I have noticed one pretty damn interesting thing about lispers. >>15 said it most clearly here:

That is why learning it is difficult– you’re going up into a level abstraction that you never imagined could exist.

As someone who knows both Lisp and Forth, I'm getting progressively more baffled by this. Like, it doesn't seem like a big thing initially, but the more I look at it, the deeper it goes.

Learning Lisp is not difficult.

I mean, come on, really. Compare it to an entry course on linear algebra and shut the fuck up, ashamed.

Sure, for someone who sees the stuff for the first time it could be somewhat mindblowing, for a couple of hours. But look around, these days you have to understand anonymous functions, closures and higher-order functions to get a job as a Visual Basic code monkey. And guess what? Even Visual Basic code monkeys do understand this shit, because it's simple.

While lispers have been saying for thirty years, and continue to say, that lisp is unpopular because the average programmer can't get map/filter/reduce and prefers "less powerful" languages.

Don't even get me started on homoiconicity. After a couple of months of learning to program, every non-retarded programmer gets a mindblowing revelation: his C compiler is a program too! And some other program could compose a text of a third C program, then feed it to the compiler, and run the result! WHOA. Whoa, man. Wait, that's obvious, I'm a little ashamed of not getting it earlier. <- that's how the natural progression should look like, unless the person in question is retarded, right?

Learning lisp is not difficult. Functional programming is not difficult. Metaprogramming is not difficult. Any sane programmer gets her share of revelations about this shit, like, maybe two or three hours of blown mind all put together, then naturally transitions from awe to the real understanding, and feels a bit ashamed for not getting these simple things earlier.


Yet lisp fanboys ceaselessly repeat profound bullshit about the "levels of abstraction that you never imagined could exist". As I said, that's not a very big deal, on the surface. But as I think about the roots, the possible reasons for this behavior, something very much like the true answer for the Lisp Unpopularity Enigma comes looming from the depths. Every reader, except for lisp fanboys, must have realized what it is by now.

>>52
Compare it to an entry course on linear algebra and shut the fuck up, ashamed.
Linear Algebra is hard not because underlaying concepts hard, but because Set Theory is a tainted jewish pseudoscience. It is like explaining programming in terms of Astrology: your program has failed, because Mars was in wrong position and God hates you. If you reformulate algebra in terms of LISP and finite lists, it will become easy as fuck.

Remeber, kids: there are no hard things, there are hard jews, that make things hard for you. Next time, you will hear about infinite sets, just leave class room.

>>1

Because this

foldr f acc [] = acc
foldr f acc (x:xs) = f x $ foldr f acc xs
is far more readable than this

(defun foldl (f acc list)
  (if (null list)
    acc
    (f (car list) (foldl f acc (cdr list)))))

Sure you can create a slow bug ridden implementation of half of haskell's syntax on top of a lisp with macros but why not use a language that has nice syntax to begin with?

Sometimes the flexibility of lisp is nice but it comes at a price (homogayiconicity) which you still have to pay when you don't need that flexibility.

>>55
>why not use a language that has nice syntax to begin with?
Prefix notation is a nice and uniform syntax, that signifies underlaying AST.

>>56
For example, jewish Set Theory uses this ugly Set notation, instead of plain lists. And it makes it agonizingly hard to learn and read.

>>56
AST shmAST. Maybe nice was the wrong word but you can't deny that the haskell example in my post is far more readable and the difference is even bigger when you have more complex code.

If you can parse a piece of haskell code twice as fast as a piece of lisp code that's a huge advantage.

>>58
I dont know Haskell, nor its syntax, but I know, that (x:xs) is a high level operation, and in your LISP example you use only low level, manual list splicing. So, you're probably a jew, that tries to brainwash us.

In my Lisp DSL, I can do foldr in one line

foldr f [x@xs] -> foldr f xs |> f x
no
>foldr `+` [1 2 3 4 5 6]
21
so, haskell sucks even here

>>59
I don't even














































































You are a jew!

>>58
>difference is even bigger when you have more complex code.
I've seen complex Set Theory expressions, and I cant read them. Even simple Zermelo-Frenkel axioms look very scary, compared to LISP.

>>60
Eh, so what?
You can easily write that in one line of haskell.
Also, you can put my lisp example in one line too, so why even mention your dsl?

Curl is superior.

>>62
           

  what Oo                            

You're the one who brought up jewcode. I was talking about haskell.

>>63
LISP:

foldr f [x@xs] -> foldr f xs |> f x

Haskell

foldr f acc [] = acc; foldr f acc (x:xs) = f x $ foldr f acc xs

>>13
Every language has syntax, champ. IHBT

>>65
I was talking about haskell.
It is this ugly jewish language, sponsored by Micro$oft, that uses {x | such that unintelligible symbol mess} notation from Set Theory, instead of simple (remove-if predicate list)?

>>66
[quote]Sure you can create a slow bug ridden implementation of half of haskell's syntax on top of a lisp with macros but why not use a language that has nice syntax to begin with?[/quote]

>>67
LISP doesnt. You can even write LISP as a bitstream, assigning to #\( and 0 to #\)

>>70
1 to #\(
fix

>>62
I've seen complex Set Theory expressions, and I cant read them.
That's because you're genetic garbage, a product of three hundred years of rapings by Mongols, and of ubiquitous alcoholism (as a mode of escapism).

Jews tried to enlighten you Untermenschen by installing Communism, you know, free education, eradication of primitive selfishness, that kind of stuff. We all know how it ended, they'd better have tried to educate baboons, to see actual improvement and at least some gratitude.

No wonder you hate Jews, it's the hate of a cripple for whole persons, complete with rationalizations, "the absurd notion of usefulness of legs is brainwashing and propaganda".

No wonder you adore lisp, you fit >>52 perfectly. And don't try to derail the discussion with your inept trolling.

>>69
why not use a language that has nice syntax to begin with
Already using it. Called LISP.

>>69
Why not to use REAL quoting,
``faaggot"?

>>68
you mean

filter predicate list
?

>>72
If not this jewish communism crap, Germany would've purified Earth from Set Theory.

>>75
And you've bloated language, that has over 9000 synonyms for remove-if.

>>66
foldr = ((.reverse).).foldl

IHTB

>>78
define "reverse"

>>77
[ascii]
lisp has both remove-if and remove-if-not
2     4  1       3                      5
[/ascii]