What is the point of LISP in the current year?

>What is the point of LISP in the current year?
Not making up a new snowflake configuration shitlang every time when you already have a tried and proven one with decades of research put into it.

Attached: Machines_are_heresy.png (250x300, 51K)

Lisp is not a functional language.

Depends on the lisp. Try Clojure. It's pretty nice to write in, and it does concurrency really well.
Almost every place where you'd need Java for your software, you can use Clojure and not be disgusted.

Neither are Haskell or OCaml then.

Very few languages provide the same freedom as lisp. Its as much of a framework to invent your own lisp as a programming language itself. The tradeoff is how easy it is to write unintelligible lisp if you don’t restrain yourself.

Clojure is quite successful. And a better language than Scala IMO.

Rather use Kotlin

There isn't much of a point other than to customize Emacs.

OCaml is better.

wrong answer

They are. You don't know any of them, including Lisp, if you say so.

All of them are provably non-functional, assuming you're not using some special retarded definition of "function".

As someone who likes Lisp, Forth fits this bill better. Everything in Forth is done via DSLs because the underlying language almost doesn't exist.
Part of why Lisp is more fun than Forth is that its proximity to normal languages means that it has something of a safety net (dynamic types instead of no types, no infinite stack underflows, etc).
Pretty much this. You get to make your own languages while still having a perfectly normal one underneath.
Lisp is Python with parentheses, but those parentheses give you macro superpowers.
Plus, live coding in an image is comfy. Write-compile-debug cycling sucks.
The arguments for typed functional programming are very different from those for Lisp. Lisp is the ancestor of Smalltalk and Ruby and Python, which are the targets of arguments for Haskell ("if it compiles, it works", type system keeping you safe, no global state, etc). They all have REPLs, but writing Lisp is more REPL-centric.
wrong

>The arguments for typed functional programming...
Did you reply to the correct post? Because I don't see how this is written in response to it.

Haskell is purely functional, as all functions are functions in the mathematical sense. The ML family can be.
Lisp, however, is not: letoverlambda.com/index.cl/guest/chap5.html

>All AI work is done in Python
>Skynet, but programmed in Python

truly the stuff of nightmares

The arguments for Haskell and Ocaml (and Scala and Rust and Elm) are given in terms of making things "safer", which is antithetical to Lisp's infinite malleability. A lot of the "functional" features being adopted by mainstream languages like Swift have as much to do with ML-style types as they do with lambdas and closures.
The "functional programming" label is a moving target. Having lambdas and lexical scope in the '90s made Lisp functional, but as other languages have gained these abilities, it has become more specific.
Lisp has always been about freeing the programmer, and functional programming, as generally touted nowadays, is about caging the programmer to reduce fuckups.
For a perspective on the Lisp community which might better elucidate what I'm saying about the (distinctly separate) FP community: nhplace.com/kent/PS/Lambda.html
FP has less to do with functions (or else APL would be as functional as OCaml, perhaps even more so) and more do with "purer than thou" attitudes.

>Haskell is purely functional, as all functions are functions in the mathematical sense.
This statement is provably equivalent to "Haskell types with the functions as morphisms form a category", which is provably false. The proof is left as an excercise for the reader (hint: use `seq` to show that `id` is not an identity).

This is a nice post, but how the fuck is it a response to what I wrote?

That gay shit doesn't really matter. It has the same power as a language where code can be represented as ASTs, which both Haskell and OCaml have macros that can manipulate AST representations of itself.

>muh funkshunul
Comparing Lisp to Haskell is pure unadulterated autism. Lisp is only functional in the strictest possible sense, most code written it is entirely procedural.

It's very nice that you had a class about this stuff today, but you aren't impressing anyone, nor arguing in good faith.
Actually elaborate, or leave your "exercises for the reader" somewhere else.

In response to
>Lisp is not a functional language
you said
>Neither are Haskell or OCaml then
I'm telling you, this argument that "both have lambdas, which defines the category" doesn't work.
The category is a soft social one loosely tied to certain technical features which free or restrict the programmer.
It's entirely possible for Lisp to not be functional while Haskell and OCaml are because FP's definition is a time-and-place-dependent thing.
You wouldn't call Java functional because it has lambdas, would you?

>Lisp is only functional in the strictest possible sense
It's not.
>most code written it is entirely procedural
Any "functional" language is by definition procedural.

Maybe you meant "loosest" sense.
I agree with the rest though.

How am I not arguing in good faith? Haskell is not "functional", since it allows you to define non-functions. It's actually trivial to construct a proof from that hint if you know Haskell. And if you don't, you shouldn't care about what I wrote.

He just opened up a book on category theory and needs to brag on the internet, leave him be. I too went through that phase once.

>both have lambdas, which defines the category
This is gibberish.
>It's entirely possible for Lisp to not be functional
Yeah, Lisp is non-functional precisely for the same reasons Haskell is. Using just the term "functional" doesn't allow you to distinguish between Haskell and Lisp, since neither are "functional".
>You wouldn't call Java functional because it has lambdas, would you?
What are you even rambling on about now?

Great counterargument.

dynamic functional language,

i like scheme more as a hobby though. i prefer ocaml of I need work done

Attached: Screenshot_20190505-220447.jpg (1920x1080, 339K)

I'm such a shitty mobile poster
>if I need to get work done

A lot of people make the mistake of saying a language is "functional" because it has lambdas. This is what your argument sounded like, although it looks like you're being more Puritan than even the Haskell people.
Perhaps I could have used a better word than "category". I wasn't talking about category-theory "category", I meant the colloquial "category of languages which are functional".
By your definition, even Agda isn't functional: semantic-domain.blogspot.com/2016/03/agda-is-not-purely-functional-language.html
>dynamic functional language.
Not really a thing, to be quite honest. I don't have a very high opinion of Clojure as a practical programming language because it doesn't necessarily do anything that isn't done better by another language and has all the disadvantages of the JVM. The typed FP community (stuck up as always) talks down to it because it's dynamically typed, and the Common Lisp community (also stuck up, but not so intolerable) talks down because it's not multiparadigm. It seems kind of confused.
Probably the closest thing to a dynamic functional language would be J. Incidentally, it's inspired by the same source as the mainstream FP community, Backus's Turing Award lecture[1], but sticks closer to its spirit.
thocp.net/biographies/papers/backus_turingaward_lecture.pdf

>thocp.net/biographies/papers/backus_turingaward_lecture.pdf
this will be a fun read for tomorrow, thank
although, I, who isnt smart and wrong in this, disagree.
I feel like a language like scheme is functional as it really feels like writing lambda calculus the way I prefer to use it. whatever, I should read more into the stuff, anyway.

>This is what your argument sounded like
Maybe if you didn't read the argument at all.
>although it looks like you're being more Puritan than even the Haskell people.
I'm just using words properly. If you (correctly) believe Lisp is non-functional for the reasons outlined in the letoverlambda article, you necessarily have to believe that Haskell is non-functional too. The term "functional" is a retarded way to differentiate Lisp and Haskell anyway. There are much better ways to do that, as you have already shown in other posts.
>even Agda isn't functional
I haven't looked into it, but that wouldn't surprise me. People don't use Agda because it's "functional", they use it because it gives them a way to describe some type-theoretic phenomena in a computer-readable language. Being "functional" isn't necessary for achieving that.

>Maybe if you didn't read the argument at all.
AFAICT, you said, in response to "Lisp isn't functional", that "Neither are Haskell or [sic] OCaml then". That sounds like the "lambdas make a language functional" argument.
>I'm just using words properly.
Yeah, well you're being an autist.
>The term "functional" is a retarded way to differentiate Lisp and Haskell anyway. There are much better ways to do that, as you have already shown in other posts.
I'm speaking of them in the way everyone else understands because they don't act retarded over minuscule differences in definition and because of Backus's lecture, which I linked in .

To be continued.

Lambda calculus was an accident. Church's original project was a full logic with quantifiers and other bells and whistles, with lambda being a single operator denoted by a hat on a variable. He dropped the rest of it when it was shown to generate the Richard paradox, and it turned out that this one operator alone could encode all of computation.
It's pretty cool that universal computation could be shown in 1935 using a single operator, but it's neither an absolute maximum of simplicity[1] nor engineered to maximize productivity.
The argument for functions (specifically combinators) being a good basis for programming dates to Backus's lecture. The point is to reason in the aggregate about algebraic transformations over data which can themselves be rewritten by hand and matched to proofs of correctness. Lambda calculus simply isn't very good at this, and static types are a crutch, a hackish fix to this deficiency.
Lambda-based programming is better than imperative programming, but we could go so much further, if only programmers would read before reinventing the flat tire ad nauseam!
[1] fexprs can encode lambda (and a lot more, no need for macros) and be treated algebraically with a few modifications: web.wpi.edu/Pubs/ETD/Available/etd-090110-124904/unrestricted/jshutt.pdf

>Yeah, well you're being an autist.
Exactly as autistic as letoverlambda.
>That sounds like the "lambdas make a language functional" argument.
How so? The argument just points out that if Lisp isn't functional because of the standard argument, so are both Haskell and OCaml precisely by the same argument.

continuation of >People don't use Agda because it's "functional", they use it because it gives them a way to describe some type-theoretic phenomena in a computer-readable language. Being "functional" isn't necessary for achieving that.
The whole point of functional programming is to simplify reasoning about the correctness of programs to an algebra. If you want to reason about things at the type level, a functional language base is ideal because it's simpler to reason about automatically.
Agda's being purely functional (or very close) is highly pertinent, or else people wouldn't make such a big deal over it.
Do you know anything about compiling functional languages and why Haskell is far closer to C in speed than to the closer-to-the-metal Python? It's because lambda calculus can be reasoned about in an automated fashion in a way that languages like C preclude because of the presence of pointers and goto.
Incidentally, it is these same properties which give rise to certain personality types being attracted to FP, because the loss of freedom allows the compiler to catch a lot of errors before the program ever runs. It is this restriction which lies at the heart of why Haskell and OCaml are functional and Lisp isn't.

You don't have to tag my post to write about something interesting but completely unrelated to what I'm saying. Just use the normal reply function.

Are you blind? It's a direct response to what you're saying, that FP is only languages in which e-v-e-r-y-t-h-i-n-g is a mathematical function (incidentally, a pointless distinction which no real language lives up to).
Do you want for me to cut up and spoonfeed you my arguments further until you stop acting like a pain in the neck?
Either this is bait, or is right.

>closer-to-the-metal Python
Who even believes this in the first place?

Assuming these statements are true - "A functional language is a programming language made up of functions.", "A function is a static, well-defined mapping from input values to output values.", it is trivial to show that both Lisp and Haskell are non-functional. Why is this so hard to understand for you? Do you have some fetish for Haskell being functional and Lisp being non-functional?

You don't think Python's abstract model is closer to the von Neumann architecture than Haskell's? As far as the Haskell language is concerned, to it everything is within the realm of a graph-rewriting machine. Only towards the end of the compilation process does the language start to look anything like the final imperative output.

I'm aware that under the strictest of definitions, Haskell is not functional because it contains features such as unsafePerformIO and IO is done via the IO and State monads.
Nevertheless, a true-and-pure, Platonically-ideal functional language would feel significantly more like Haskell than like Lisp.
Lisp allows you to do functional programming, just the same as it allows you to do imperative and OO programming because it's not opinionated.
The original question was "should I learn Lisp to learn more about functional programming", and the answer was a resounding "no" because Lisp is significantly more different from functional programming than Haskell, and, moreover, the arguments for learning Lisp are not those for learning Haskell (the arguments for which match up perfectly with arguments for purely functional programming).
Why do you keep making autistic asides to Lisp and Haskell/OCaml both not being purely functional? One is a lot closer to being purely functional, to the extent that it's almost the same in practice. Your argument stinks of disingenuity by now.

>Haskell is not functional
Good. I'm glad we agree. I can already tell without reading that this is the only relevant part of your post which directly addresses what I'm saying.

lisps are fun languages
every time I sit down to write common lisp it's pure bliss

Attached: 1554841985451.jpg (512x512, 38K)