Is Lisp the undisputed chad?

Attached: chadlang.jpg (600x375, 12.14K)

Other urls found in this thread:

reddit.com/r/ProgrammerHumor/comments/8784sg/writing_lisp_without_matching_bracket_highlighting/
twitter.com/AnonBabble

I haven't seen a benefit working with it.
I don't like that I have some control structures which are functional like (if) and some which are imperative like (unless). You have to add (begin..) to get back to normal.
I hate lisps where you have to put (let) to declare variables because you have to deal with yeat another set of parens.
There's too many ways to do anything and still you need extentions that look weird for oop or short form declaration #crap(blah)
I don't like that there's a big focus on REPL. REPLs suck, let me just compile a normal program and run it.
There's also no reason not to have a built-in macro for normal math. prefix notation is not good for more than 3 terms
Finally, the basic unit is not even a normal list. It's actually a "pair" which means it's ambiguous as to whether it's a list or a tree.

The real positive of lisp is the fact that you don't have to put commas or colons when calling functions. And that you rarely touch the shift key. You really notice this shit when you go back to python and type something like print(a[0], a[1])

>he doesn't use macros for shit like () => ->
pleb.

oh yeah and the lambda syntax is lengthier than python wtf
Java: x -> x+1
Python: lambda x: x+1
Lisp: (lambda (x) (+ x 1))

no shit. Lisp is just a step above a literal AST. It's memey as fuck honestly.

it wouldn't be too bad if they inferred the parens on newline and indentation and a few other situations like so:
(define (scream slur1 slur2)
(define suffix ", you and your mother")
(cond
((based? slur1) (display slur1))
(display (join slur2 suffix))))

to
define scream slur1 slur2
define suffix ", you and your mother"
cond
(based? slur1) (display slur1)
display (join slur2 suffix)

>it wouldn't be too bad if they inferred the parens
That sounds awful. Lisp have problems, but parenthesis is not one of them.
People getting filtered by the parenthesis are the same people who never tried lisp.

lisp's ideas will always be wasted on its ugly paren soup syntax that takes a thousand hours to get used to
retards can cry all they want about "lol filtered you should just try it" but life isn't fucking fair and usability matters

>muh parentheses
retard alert!
>There's also no reason not to have a built-in macro for normal math. prefix notation is not good for more than 3 terms
prefix notation is far more sensible and less ambiguous than legacy infix notation
Is this supposed to be an argument against lisp?
Strictly speaking Emacs shows lambda as an actual lambda so it's only (λ (x) (1+ x))
kek
do pythonshitters really
>filtered

common lisp is actually fun to program in. its fun WEEEEEEEEEEEEEEEEEEEEEEEE

>use emacs
>type paren shit
>forget to close paren
>all garbage
>useless error message

It's really annoying. Most of the emacs major/minor lisp modes are too fucking different to get use to.
As already said, it's basically just a step up from an AST. Also quoting looks like aids. Fuck anyone who thinks otherwise. No it's not hard to reason about, but it's about as readable as all the other autism macro languages like m4.

>prefix notation
technically it's functional notation
real prefix notation doesn't need parentheses while S-expressions need them

>And that you rarely touch the shift key.
Are you sure? It doesn't sound right to me
maybe you are thinking about kebab-case which makes me wonder why there are no other language who does this. I know it's probably because otherwise the infix subtraction without space would generate some subtle error but it can't be the only reason

Anyway lisp is crap most of the time. It would be a ok language, but it attracts low iq-high hubris retards and thus make the language shit to use

>People getting filtered by the parenthesis are the same people who never tried lisp.
It doesn't look annoying at all
reddit.com/r/ProgrammerHumor/comments/8784sg/writing_lisp_without_matching_bracket_highlighting/

Lisper not complaining about parenthesis suffers from Stockholm's syndrome

>infix subtraction
Pretty sure that is the only reason. Allowing kebab-case means you either have a situation where x+y and x + y are the same thing but x-y and x - y are different (or worse, where the meaning of x-y can change if someone adds a variable), or you require all infix operators to have spaces around them (which is probably even more annoying).

>you rarely touch the shift key
I have to use shift to get parentheses, you insensitive asshole!

my experience has been
>use emacs
>type paren shit
>emacs autocloses the parens for me
>useful error message

Lisp is the Dwayne Dibley of programming languages. None of the other ones compare.

>writing it by hand
good thing nowadays we have editors that autoclose your parens and autoindent based on the parens and highlight your parens so you always have it right. You've never actually tried it have you?

Python lambdas are not real lambdas, they're extremely crippled and can't do much. Not an argument.

> You've never actually tried it have you?
I little bit. I rather being able to use whatever ide/editor because some handicap in the syntax, just like colorForth
Also, auto closing parenthesis are shite, I want to close it by myself and more importantly I dont' want to drag some closed parenthesis while writing code

The only way to write lisp semi-confortably is using emacs and I find it disgusting

There are plenty of alternative syntaxes for lisp. The difference with lisp and other languages is that they're implemented IN LISP instead of as a different language or operation step (e.g. preprocessing). See sweet-expressions and m-expressions for two examples.
Parentheses and prefix is actually an insane advantage over other languages, advantage which none other has been able to reproduce so far. If you don't know why, you haven't used lisp before.

go back
i type ( and emacs automatically adds a ), at which point i simply type what is necessary
then C- select a region and type ( to enclose it in parentheses
simple as

> Parentheses and prefix is actually an insane advantage over other languages, advantage which none other has been able to reproduce so far. If you don't know why, you haven't used lisp before.
Lisper thinks they are parser-compilers, from the pov of a developer that don't represent any pros.
And macros are overused 90% of the time

>Also, auto closing parenthesis are shite
This is true, the only thing you want with lisp is highlighted parentheses though, everything else is bloat.

>The only way to write lisp semi-confortably is using emacs and I find it disgusting
This is bullshit, I've never had a good time with emacs for lisp. I use vim + slimv instead.

Macros are nearly unused in lisp programs. They are unrelated to lisp's strengths, and overstated in books for retards because only retards write lisp books.
Lispers don't think they're parser-compilers, they think (rightfully) that they're using the most powerful programming language known to man, for which the only languages that come even remotely close are smalltalk and forth, except of the three, only lisp is practical.

> hey think (rightfully) that they're using the most powerful programming language known to man, for which the only languages that come even remotely close are smalltalk and forth, except of the three, only lisp is practical.
1. Lisp is not that good
2. You sound like a retard larper who never used smalltak or forth. btw smalltalk is order of magnitude nicer than lisp

Forth is shit anyway. The incremental developing concept is cool but other than JTAG is still shit

both vim and vscode have lisp interaction modes that i assume can do the same paren stuff as emacs. the most useful thing aside from paren match highlighting is how it autoindents based on the nesting. After using it for a while you get used to a certain look, and when something indents further or less than you were expecting, it becomes super obvious and you know you have a mistake. You really do stop worrying about the parens.

have you ever tried lisp before?