Is there any point to learning LISP today other than for fun...

Now i'm left with derivatives of SML, your point?

>There's crapton of things Haskell gives you that lisp can't.
Such as? Before you say these stupid things, remember that Lisp has unrestricted compile-time metaprogramming. That's unrestricted freedom. You can have a type system with HM inference if you want, for example.

Do you not even use Emacs?

where do programming language hipsters even come from
what is the purpose to their existence

please remember that typed lambda calculus was invented solely so lambda calculus would abstain from being paradoxical, and would be logically consistent.
As a result of this, it is not turing complete.

Haskell is trying to create a general programming language based off of a system that is designed not to be turing complete, of course its going to be a shit show.

Also, here is something that lisp can do that haskell can't:
Can you create a metacircular evaluator in haskell in less than a page?

>(((LISP)))

Attached: 1412150160625.jpg (523x355, 78K)

>haskell and lisp
>lowlevel

if "old" languages were out of the question, i'd rather recommend golang to someone as a general-purpose language because even though it has its share of flaws, at least it doesn't have a bloated runtime like .NET or JVM. but i don't see what age has to do with choosing a language

Attached: This is bait..png (625x626, 30K)

How is lisp low level, it theoretically doesn't even touch the hardware, it is designed as a formal system that doesn't require a computer to use.
By this logic the entirety of mathematics is "low level."

Low level as in syntax. Closer to English, easier to write and read. Additionally - who the fuck is still looking for Haskell & Lisp programmers? Literally no adverts have I seen.

>That's unrestricted freedom
So? I can implement a haskell compiler in asm, that doesn't make it as good as haskell. How practical will your bootleg H-M type system? How much time does it take for your coworkers to get efficient with it? How helpful are your error messages?
>turing completeness
Oh this meme again. Show where, in practice, you can't do something in Haskell that you could in lisp.
>Can you create a metacircular evaluator in haskell in less than a page
I can't, but i can write a self-interpreter in less than a page.
Now an excercise for you: can you prove that your self-interpreter in lisp halts in less than a page?

>can you prove that your self-interpreter in lisp halts in less than a page?
proving the correctness of programs is for brainlets

You say bloat, I say function and ease. Slap Dev Express on top and you are one productive motherfucker.

>t. frontend code artisan

It is my solemn and unfortunate duty to inform you that you are woefully misinformed.

the people who harp on about how great haskell is for catching errors spend more time complaining about programming than actually doing it
no decent programmer has problems with buggy code

The day I discovered the magic of call-with-current-continuation and what people were able to build with it, my brain exploded.
I realized all I had done until then was just toddler-tier.

Well, you must be one lucky bastard if you have never had a bug in your output. That or you don't do much.

>spend more time complaining about programming than actually doing it
Because with haskell, you don't have to spend weeks debugging and rewriting your shit so you have time to waste your time complaining about languages you don't use.
>no decent programmer has problems with buggy code
Such as? Literally only Jow Forums larpers say shit like this. No wonder your hello word or sieve (probably) doesn't have bugs.

The world weeps in gratitude for your service.

everyone has bugs, if you are decent fixing them isn't usually difficult, you don't need strict pedantic compile time tools to stop some of them from occuring

Perl is the only high level language that is worth using.

I have spend decades programming large complicated programs and I've never had a serious debugging problem (at least not one that would be fixed by the featureas haskell offers), the last time I wrote buggy code was when I was a teenager and hacked shit together without thinking about it
I'm convinced everyone preaching the benefits of these languages are fresh out of college with no experience

I personally think lisp is pretty nice to read, especially compared to some other languages that use tons of symbols like Perl. That's only my opinion, and it's skewed since I happen to like lisp as a language. I like english-like languages like python for readability, but I think there can be other approaches to structure. After all, english is not turing-complete as-is. I mean, I hope not. Seems messy.

About the adverts thing: I have seen adverts, but that's beside the point. I've slowly gotten redpilled about the worth of languages; I don't think a language needs to have lots of jobs to be relevant. Why? The popular languages change. We did eventually stop using COBOL, Fortran and such for new projects, python has gotten big, so have js and a bunch of web languages. Now, we see memes on the horizon like webassembly. Current memes like typescript have partially replaced javascript. Those are relevant because we, as a community and an industry, strive to make better technology. This includes making better workflows. Sure, we can't just make a language and say it's better than others and be done with it, Rust proves this. C isn't going to go away anytime soon. However, we do need to be aware that technology isn't in stasis. The industry won't stay how it is forever. With complex AI and other kinds of analysis, we're getting to really good code analysis. We need to find ways to curtail spaghetti code since so much of the world is running on it. That means trying to have languages which minimize irregularities and cruft. This, in many cases, means having higher level languages or low-level languages with syntax extensions that clean them up.

TL;DR: Languages won't stay constant. Learn other languages to get a good understanding of different paradigms.

You either learn language for usability of for education. Lisp has some concepts that are worth learning but usability is kinda overrated.
Also most beginners judge language by it's syntax, but that's the somewhat irrelevant part.
In case of Lisp, knowing S-expressions is good to know. It ensures that the language has context-free grammar. You should judge it as serialization format for syntax tree. When making a new language, Sexprs are the simple choice since you write your parser in one afternoon and never have to worry about it again, having your time spend on more relevant issues.
When it comes to concepts in a language - this massively differs between specific Lisp languages and there is something new to explore in every single one of them.

English doesn't have formal semantics so it can't be Turing-complete. As a formal language it's much more complicated than any programming language though. We should make an international language that's easy to parse for our future robot overlords.

there are such things
>Earth Minimal
>Lojban
>Dutton Speedwords
>Tepa

Attached: lojban.png (450x392, 23K)

Lisp has a better job of getting you a job.

If you want to get a job, you should learn a language like Java or C#, since these languages are designed to remove programmer agency and treat the developers as problem-solving automata with their certificates and standard design patterns.
Or you could learn languages like C or C++ where the language's design leads to incomprehensible complexity in large projects, requiring hundreds of developers to maintain aging codebases.
Or, you could learn a language like Python that's mostly useful for glue code for other libraries you didn't write. You'll borrow the critical parts of an application from someone else, but combine them in a new way to quickly make a product for a startup.

Lisp in the industry is in an interesting position where it's been used for practically anything with good results, but has never been the primary language of anything else but AI. You could work on literally anything, but there's only one software mill that uses lisp in any given field.
And this is a direct concequence of the flexibility of the language. When everyone on your team is capable of implementing their own object system and HTTP parsing library, your programmers simply have too much agency to work on a shared codebase. You know how the JavaScript ecosystem looks, JavaScript suffers from a similar flexibility issue. Only it's more widely adapted.

As a language for your own projects though, there's no better. There's little penalty to the flexibility when you're a one man team, or even two or three.

Haskell is a language being made bottom-up: instead of starting with a set of ad-hoc features to make the language do what you want, it started off with a solid mathematical foundation that had no use. So far people have figured out how to describe effects in a reasonable way but Haskell still lacks mature libraries. And I'm not sure it will ever change.

Attached: haskell.png (1373x955, 33K)

>fresh out of college with no experience
8 years in defense. Strong type system would prevent majority of bugs i've had to track and fix.

well I wouldn't object to using a safe language if I was programming military hardware

You shouldn't object to using a safe language if you're doing actual work and not just fucking around.

If I'm just writing software software that doesn't kill people when it fails I'm going to choose productivity over stability

It's not just about safe. Ada can be safe too, but it's a pain in the ass compared to Haskell. Haskell gives you so much out of the box, no need to fall back to something SPARK platform in majority of code. And if you do, you can just enable the dependent types directive and seamlessly compile in a single environment.
Haskell is arguably more productive than popular languages. There are systems where you'll have to jump through useless hoops, but overally Haskell is very expressive. Bonus point: documentation writes itself because you can infer pretty much everything relevant from the type signatures.

>Haskell is arguably more productive than popular languages
Well I'd argue against that, most real-world programs aren't suited to being pure functional

And Haskell has tools that aleviate the pain. Check XMonad to see how expressive it can be even in the case when it's not well-suited for given system.

Or I could just use a normal language and not have to worry about it

If you want a job, learn a language which is popular.

What does that give you? You argued productivity is an issue with Haskell, i gave you an example where Haskell is productive despite the system not being suited for purely functional paradigm.

so just limit yourself to walther recursion?

>dynamically typed functional language
why would you do this

Well I can't argue the specifics because i haven't used that program or know much about Haskell, but just because you can do something doesn't mean it's optimal

Dynamically or statically typed multiparadigm language.

why not

many programs are suited for the functional-core/imperative-shell pattern

yeah
isnt that just a normal program though

Not even that. Using directives, you can force ghc to only accept code that guarantees termination, not neccessarily just by reducing to walther recursion.
You can't guarantee termination in lisp unless you prove it by hand or force the lisp interpreter to prove it, in which case it isn't a complete language, just like terminating subset of haskell isn't complete (but default directives make Haskell a turing-complete language, despite me saying it is a meme - it is).
The point is you can't do it in lisp unless you spend significant amount of time on it, while with haskell it's a matter of flipping a few switches.

>conflating the language with the compiler

>itt, bunch of morons trying to justifying using garbage like lisp and haskell

it's another neet day in Jow Forums

what flags are these?

If you want the default haskell, then your assertion that it isn't turing-complete is false. And i can still prove termination much easier than in lisp.

>assertion that it isn't turing-complete
no one asserted this.

Learn Scheme, Clojure, Prolog, Erlang and/or Elixir, SML, Haskell. Each will improve you as a programmer. Clojure jobs exist. They may even be more common than Haskell jobs, but both are rare.

Reading textbooks on Artificial Intelligence from the 70s.
All of the code is in LISP.

Libraries are a problem but worse is the unpredictable performance and the incredible (in the sense of "I can't believe it's taking so long") build times. A major problem with Haskell libraries is that out of two apparently similar ones one can be dog slow and the other okay (but still 2x-5x slower than if you called the equivalent C# library from F#).

Return type polymophism is a big one for me. See softwareengineering.stackexchange.com/a/105663.

It's sad I can't completely discount the possibility that this post isn't a troll.

>Closer to English, easier to write and read
So what's your favorite language, COBOL or AppleScript?

Undelimited continuations are bad.

For the OTP.

this. Delimited continuations are where it's at.

no, it's literally language that was never finished and then became like 50 different flavors of the same unfinished design.

>unpredictable performance
>laziness by default is completely new to me, but it's the language's fault if I can't reason about it

First of all: what do you mean by "never finished?"
Never got the complaint about multiple Lisps either. I mean, nobody complains about the multiple Algol flavors (C, C++, Java, C#, Pascal, Perl, Python, Ruby, etc.).

>isnt that just a normal program though
that makes it many

Can you make Lisp go fast? Like C-levels fast?
If not then it's a useless language. Currently used processors are not stack-based but register-based, we're not using Lisp Machines anymore.
Invent a modern equivalent of a Lisp Machine, optimized for Lisp, and you will save the world. For the time being the processors we use are optimized for C-style languages.

Lisp is fun for doing rapid prototyping.
Let's say you want to write decentralized Jow Forums-style image board. You use Lisp to produce a pile of highly abstract hacks to do this in under a month. After you've done this in Lisp, you now know a great deal more about the problem than when you started, and take everything you've learned to a more suitable language for this to write it properly. Or you just ship the Lisp abstraction and not give a fuck.

Developing in Lisp is also awesome, you don't write test cases and shit or anything. You simply grab what function you've just written and run it by itself, interactively playing with it. There's more information here: stevelosh.com/blog/2018/08/a-road-to-common-lisp/#lisp-as-a-system

As for 'jobs', well you can crank out MVPs and sell the idea/prototype, or you can work for GrammaTech or IBM with their Quantum Computer algorithm design research team. If you want to work with a statically typed language, you would want to use OCaml over Haskell anyday of the week because you get optional instead of enforced lazyness. This means you can actually prove your code using simple induction, giving a strong guarantee of correctness whereas in Haskell you can't do this. OCaml also lets you just 'get things done' when it comes to I/O shit like parsing a network transmission frame or reading from media. This is a huge pile of boilerplate in Haskell. You can also run purely functional code in OCaml if you wanted. Type driven development can also be used for rapid prototyping with the added benefit of your final draft if it runs, it's likely correct.

You can glue any C libraries you want with any Lisp. You can also use it to help you optimize your compiler, which is what companies like GrammaTech are doing.

That's not what I'm talking about.
Lisp is a garbage-collected language, therefore it's too slow to be suitable for real life usage. Probably better than JS tho

>It's all so tiresome
Not this 'it's garbage collected!' again.
Companies like Jane Street tune and sometimes even rip out the garbage collector at their whim for doing whatever they want in OCaml. You can do the same thing for Lisp, or, like I said, use it to glue Libraries together which are run in C, the Lisp glue is just providing and abstraction over said libraries so you can do crazy insane things like build a server that accepts a video as input, runs some kind of optimization or machine learning library over it, and returns a new video. All that low level work is done in the C or other libraries not Lisp it's just the abstract glue.

Didn't mean to annoy you. Thanks for the post

No. Faggots can't even make a simple text editor with it. Nothing of importance is made with lisp. All lispfags do is circlejerk to quarter century old manuals.

Guess why not a single book on AI today uses lisp? Because it's useless obsolete shit, completely superseded by better languages for purpose. Python+C is default now.

>Lisp is a garbage-collected language, therefore it's too slow to be suitable for real life usage.
lmao wat

Neither, VB.NET is. Case insensitivity for the win!

>c-f
>clojure
My man! I highly recommend Clojure, and it's sibling language Clojurescript.
For an example of what it looks like, both client and server, see this guy's chatroom.
briangorman.io/posts-output/2018-3-4-chatroom/
hablamos-chat.herokuapp.com/

You dont need to use a language like Haskell to deal with immutable data, Clojure moves away from being stuck in the cons cell and is built on immutable data structures which makes it a more abstract Lisp it is better for dealing with real world data. Also there is EFL (Lisp Flavored Erlang) which is a Lisp that transpiles to Erlang and gives you even greater immutability than Clojure.

>I'm just butting in here without knowing the full context of the posts, however...
you can do that with many languages, it's not exactly a 'highlight' selling feature for lisp desu

Lisp is the alphabet of computing. Every other language is secretly converted to lisp before being compiled or interpeted. Haskell is just math; it really doesn't have to do with language and computers.

t. has no idea what the fuck he's talking about

Can you develop in ClojureScript without the JVM yet?

DO IT FOR ZE LULZ

This is one of the reasons Jane Street chose ocaml over haskell. since the compiler is "dumber" it allowed them to be able to estimate their code's run time.
You could also take a look at this article on why it's easy to incorrectly implement an algorithm but convince yourself it's correct in haskell and then have a "wrong" runtime
garrisonjensen.com/2015/05/13/haskell-programs-are-lies.html

Is there any point to learning any programming language other than for fun? All programming job are taken by Indians anyway.

starting comfy Clojure job in about a month

Lisp can do live programming and interactive debugging, as well as things like live migration (via continuation serialization), features that nothing beside smalltalk can even pretend to and which have significant impact on productivity. Moreover, other languages already use ffis to run fast C code for everything (just look at the state of python libraries), while most lisps have infinitely better ffis, sometimes with even the ability to write inline C code (in the same way that you can write inline asm in C), while naturally being significantly faster than most languages.
Additionally, lisp languages are insanely productive because of their higher-level constructs and the homoiconicity and macros.
If you care about jobs and therefore are too pleb to make your own company or work freelance, the only functional language that might help you is F#, everything else has 0 jobs. You should instead learn python, java, C++ (less nowadays), and javascript with node.js.

Research shows otherwise, that is that people experienced in dynamic languages do not make more mistakes per line of code on average than those experienced in static languages, when using their favored language.
The difference is that the dynamic users need to write more tests. Personally I find type annotations like in chicken scheme to be the right balance.

You can try Lumo. It's experimental, but functional.
github.com/anmonteiro/lumo

isn't that every day

How do I make my own company? And doesn't freelance work pay literally pajeet-tier wages?