Common Lisp is too hard.

I still can't get my head around prefix notation. I heard Scheme is easier though. Seriously, why do practitioners of Lisp-like languages claim it's so good? I honestly cannot see the big deal, it's an old, slow, awkward and overall clunky language to use.

lol holy shit you fucking faggots

If you just learned lisp yesterday (or you're slow and you've been learning it for 10 years but still think it's the best thing in the world), infix arithmetic is better!
Simply fucking is you idiot.

The reason prefix notation is better is because you have a single uniform representation of code and [u]data[/d], the language is homoiconic.

(= CODE DATA) ;; BITCH DO YOU UNDERSTAND??

something like 2 + 4*x is BETTER than (+ 2 (* 4 x)), ALSO 2 + (4*x) is just TOTALLY STUPID LEARN TO CONTEXT FREE PARSE IN YOUR HEAD!!!!

Look I doubt any of this is getting through to the smug lisp newbies and the C faggots (even more inexperienced than smug lisp newbies) but as a summary:

* Every language (ignoring shit ones) is different and will stretch your mind and let you program in a new way
* Lisp has prefix notation and s-expression because this works beautifully with homoiconicity, macros etc
* Infix arithmetic is more readable, easier to manipulate algebraically so it IS simply better -- this does not detract from the beauty and elegance of Lisp
* THERE IS NO LANGUAGE WAR/CONTEST, IF YOU DONT KNOW HOW TO PROGRAM WELL IN EVERY SINGLE LANGUAGE YOU FAILED ARUGING ABOUT PROGARMMING LANGUAGE CHOICE IS FOR CHILDREN AND REDDIT USERS.

.... I think that I had a point..... didn't I?

The reason prefix notation is better is because you have a single uniform representation of code and [u]data[/d], the language is homoiconic.

If you mean the fact that in Lisp everything is a car, a cudder, or a paren (a list generally), then yes, I agree. The car of any SEXP is the operator; the cudder are the arguments. This way, you can clearly see the operator of any expression. The prefix notation also makes the INDENTATION prettier.

>>42
[u][b]DICKS[/u][/b]

I meant DICKS.

>>41
Nothing in your post made any sense whatsoever.

And you also fail at BBCode.

An hero tiem.

>>41
The reason fucking men in the ass is better than fucking women is because you have a single uniform representation of gender, the fucking is homosexual.

(= PENIS ASS) ;; BITCH DO YOU UNDERSTAND?

I DO NOT NEED TO EXPLAIN THIS ANY FURTHER, THE TERM HOMOSEXUAL SHOULD BE PROOF ENOUGH.

>>41
The reason prefix notation is better is because
...it's easier to parse. Especially back then when LISP was still remotely relevant. Zing!

>>47
Back then?  They didn't have Haskell back then, how could they have parsed Lisp?

protip:
it's (+ a b) because '+' is a function

>>48
It is a mystery.

PS: Haskell reeks.

HMM

TESTING

Last test

4.*(73.*(5.+(10.+(8.-(8)))))

Valid Ruby

int a = 4 * (73 + 5);
As opposed to
(setf a (funcall #'* 4 (+ 73 5)))
Tell me which one is easier to read (HINT: it's not the latter)

Oops slight error in the CL:

(setf a (funcall #'* 4 (funcall #'+ 73 5)))

>>55
and why setf? maybe a simple (with) would be ok. something like

(with var a = (* 4 (+ 73 5)) in ...)

>>57
No, you cannot use with, this is outside the problem domain.

>>57
What the fuck is (with)?

>>56
Don't you mean (setf a (apply #'* (list 4 (apply #'+ (list 73 5)))))?

>>59
It's a macro which allows you to make closures.

>>61
But why do you guys keep talking about it like it's standard?

Because it's in the CL ansi standard.

>>62
it's not standard, then again neither is (iter), yet everybody uses it. It's a general binding macro, includes let, multiple-value-bind, and stuff.

>>64
Iterate I know, but I've never seen with mentioned outside /prog/.

>>63
l2hyperspec

>>65
maybe I'm the only one here who uses with, so you everytime you see it here it's because i'm using it.

>>67
I think that's very likely.

>>68
yes.
but i'm not >>59. then again it's not a macro to create closures.

>>14
wow, what a fail language.
here's fizzbuzz in a much cleaner language:
: d dupd mod zero? ;
100
[
 1+ 15 d [ drop "FizzBuzz" ]
 [
  3 d [ drop "Fizz" ]
  [
   5 d [ drop "Buzz" ] when
  ] if
 ] if .
] each

>>70
That CL version is maybe more verbose than necessary.

>>71
all CL is more verbose than necessary.

>>72
All CL is exactly as verbose as necessary.

>>73
x g f >>> [code](f (g x))[code]

>>74
Your first example is insufficiently verbose.

(loop for i from 1 to 100                                             
      do (cond ((= 0 (mod i 15)) (format t "FizzBuzz~%"))              
               ((= 0 (mod i 3))  (format t "Fizz "))                   
               ((= 0 (mod i 5))  (format t "Buzz "))                   
               (t                (format t "~a " i))))

>>76
Forgetting some newlines there?

>>76
I didn't think it was possible for anyone to fail FizzBuzz. Obviously, I was horribly mistaken.

>>75
how so?

That lisp crap isn't taught in my skool. Best decision they ever made.