Jow Forums what do you think of common lisp

Get the basics of LISP and read the core paper on the language regarding it.
www-formal.stanford.edu/jmc/recursive.pdf
Especially pages 19/20. Those two pages describe the entire language in and of itself (Apply/Eval). The power of lisp comes that it can be described by itself rather shortly - code is data and data is code, and that can have some cool results.

Practically, some LISP dialects like Clojure are cool, I wouldn’t waste too much time in it unless you’ve got a special interest. I’d say the core strength of LISP is meta exploratory programming and quick compiler implementations (with use of LLVM if that fancies you). But yeah, if you don’t need a rapid compiler, don’t get intense into it.

On the other hand, if you wanna know pure functional programming, learn Haskell well - it’ll make you a better programmer. I agree with That dynamic languages can be fucking shit as good practice is 10x more important and spaghetti code can easily happen and knowing what things should be can become difficult.

you're just one of those kids who write 2-hour task in shitty outdated dialect in a span of year, and then shitpost about it on Jow Forums for the rest of their life. there's a good reason no one uses dyntyped languages unironically(except brainlets like you obviously. could we blame you for getting trolled into it? you're incapable of knowing any better)

Attached: group-safe16-587fc524f740279d1c0612d6a132f7ab-setz chosen undead knight lautrec of carim priscilla t (578x864, 492K)

I was having sooooo many fucking problems setting up the environment for building it. Is everything for F# installed through Nuget? I least F# has to offer but getting it to work has been silly for me.

>it won't take you much time unless you're a retard.
Herein lies the problem

Should I attempt to learn Lisp, or should I just stay away from something so complicated should I do something stupid

Attached: qiwhle070la21.jpg (400x400, 30K)

>That dynamic languages can be fucking shit as good practice is 10x more important and spaghetti code can easily happen and knowing what things should be can become difficult.
Saying Lisp is shit because it's dynamically typed is like saying C is shit because it's memory unsafe. Any modern CL implementation will bitch at you for doing weird things with types, it's not like webshit languages where anything goes.

>there's a good reason no one uses dyntyped languages unironically
Most dynamic languages are shit, but this is still a colossally retarded statement. Writing fizz buzz in Rust doesn't make you productive either.
If you're retarded, try Go instead.

i woudn't know, i dropped it after doing helloworld in vscode and just went back to rust, since f# won't be implementing hkt anyways.

Attached: group-safe0-a8326913fe3ff1e1a98ddd1189ce3b93-setz priscilla the crossbreed seaport hime dark souls k (1023x724, 224K)

it's not complicated you fucking sweaty-feet brainlet, go and rtfm right now instead of asking around.

Attached: 1310246424001.jpg (268x265, 62K)

I haven’t played with CL that much, so I wasn’t aware of its compiler yelling at you. In that case, it sounds much more reasonable. I suppose my fears of Python are rubbing out on other things.

But yeah, I’d say the main concern is the lack of good documentation, along with the lack of major use in industry (therefore it’s not forced to update). Good and bad I suppose, but isn’t good if you want to be a professional LISPer.

It’s a shame. It’s more user friendly than Haskell and I could prototype stuff pretty fast. I’ve never used Rust, how would you compare it to other languages?

I was trying to get into common lisp recently, but no libraries, no activity on many github repos, fuck emacs, and it's just fucking hard to work with w.r.t. tooling. The idea of lisp itself is absolutely worth learning and studying, but Clojure is far superior to Common Lisp, aside from the cancer known as the JVM/Java.

right now it's ``OK". hopefully it will get better. i myself work in grafix so i really had a choice between good old seppls, rust and f#. rust seems to have all that f# has and it's sure as shit better than seppls.

Attached: plain doll-safe7-49f71bd0c18b7baf3e89063003340b67-plain doll bloodborne from software 1girl bloodlin (1101x777, 770K)

rust is shit

use nim faggot

It seems like it could become useful, but who knows until it’s been 10 years. I have no idea what seppls is, but I’m also not a graphics person. System engineering is cool, but since I went to a shit Uni it’s hard to get into.

>70342028
OP Here.
Can confirm.

Wrote search.jordanbpeterson.com in Clojure

The only reason I asked this question is because I was wanting to get a feel for what type of programming YouTube channel I should start. I was gauging Jow Forums's interest in Lisp, since it is the language I know most about. The Lisp community is shit and I doubt it will grow much. Libraries are really really terrible.

Will probably make a YouTube channel that focuses on learning core GNU tools by reimplementing them in Rust or something like that.

system engineering is actually extremely dumb area of programming. c++ guys are some of the dumbest people i ever met, after java retards. i guarantee you if you're not a system engineer and not medically retarded you can do system engineering, since you're at least as smart as the smartest system engineer.

Attached: negev (girls frontline)-safe4-fb9a89f6afb45f4e5aa99a4f42e839e2-taesi negev (girls frontline) girls f (750x960, 469K)

>learning core GNU tools by reimplementing them in Rust
zero people would watch that. literally even you yourself wouldn;t watch that.

if you want youtube fame crossdress&voxmorph as a cute girl and make videos about solving simple quizes in python while acting cute.

-don't you know? dressing as a girl makes you batter at programming!

Attached: group-safe6-ed6064719df9021cdeafe803cbb88a36-grizzly mkv (girls frontline) lee-enfield (girls frontl (296x330, 599K)

It is still sometimes used in industry, but mostly for in-house software. There are still a few old-school commercial applications being actively developed IIRC.
>The Lisp community is shit and I doubt it will grow much. Libraries are really really terrible.
>Will probably make a YouTube channel that focuses on learning core GNU tools by reimplementing them in Rust or something like that.
Doesn't sound like shit community and libraries are much of a deterrent. :^)

probably doesn't mean definitely. you are definitely correct about rust, but rust is still growing while CL is on the decline.

> literally even you yourself wouldn't watch that

face palm. 100% accurate.

The metaprogramming, compile time programming, runtime compilation, diverse+mature implementations. and dynamism which is still unmatched by modern languages (condition/restart system, CLOS etc.) bring at least as much power and time-saving to the programmer as an advanced static type analyzer does. They are different advantages. Both Lisp and ML have their places. Though the SBCL implementation has decent static type analysis itself.

Stupidest language in the world. No, it will not make you a better programmer. It will make you a better functional programmer, but you will need to be a good functional programmer exactly 0 times in your life. It's a meme, it's gay, and it's a waste of time.

> CL will make you a better functional programmer
This guy does not know Common Lisp, disregard his opinion. FP is only barely supported in CL, and learning a lisp will make you a better programmer primarily because it will make you understand the inherent bullshit of boilerplate and synyax, and show you the joy of hacking on the programming language itself.

Lisp seems like a really bad choice as does haskell and rust (the guy promoting it is talking about possible future maybies not real features). Why not focus on a practical non-meme language with more than a tiny handful of employment opportunities or learn different techniques, methods, paradigms, more buzzwords, platforms, and architectures using the languages you already know. Barely knowing several meme languages isn't going to help you write one-off firmware, implement some badly written matlab in [low-level-language], or make a shiny but bloat app in electron.

why is it better than scheme

Less academic mainly. CL is an industry tested language with the advantage of an ANSI standard.

Attached: troll-level-president.jpg (587x480, 37K)

>stay away from something so complicated

LISP is literally some of the simplest shit possible. You do whatever the fuck you want with it and have less to worry about than you do in most languages because there are far more failsafes in it to let you recover from your mistakes. It's an utter meme that it's only for genius super hackers, C is far harder due to how much more unforgiving it is, it's just 'weird' to most people because you don't write shit like you do in middle school algebra class and that freaks people out.

I've heard CL is bloated, and Scheme is more minimalistic. Is this true? Are either preferable to Haskell?

the absolute state of Jow Forums

>I've heard CL is bloated

CL contains tons of useful shit built in, though with some amount of redundancy. IT's worth it just for the CLOS alone, which is still the best object system of any language.

Common Lisp was designed by the industry, and Scheme and Haskell were made for academics. Use Haskell if you want type system shit, Scheme if you want purity and continuation shit, and Common Lisp if you want to be a JPL hacker.

What the fuck is lisp even used for

Here's a compilation of examples some webdesigning Lisp fanboy made
lisp-lang.org/success/
A recent example is that writing quality analyzer that's blowing up recently, Grammarly. The meat of the application is written in CL. It seems to be a good tool for startups and other small teams that need to work fast, and is often replaced when the project moves to a larger team. See also this famous article:
paulgraham.com/avg.html

Bloated by 1980's standards maybe.

The scheme standard, such as it is, is famous for its minimalism, though recent revisions make it less so. Any given implementation will likely add features, so schemes range from light to less light. Racket started as a scheme, for example.
Haskell is a totally different language, it's like ML but with tightly controlled side effects and lazy evaluation, and ML is (kinda) like lisp but with an advanced static type system and without the dynamic aspects.

Which would you recommend? What are the advantages of each? I'm not sure what the use cases are for Lisp vs Haskell.

No. Bloated by any standard. It is a bastard child.

Rust is growing, but its community is catastrophically shit, a mix of web faggots and C++ devs that are too brain damaged to know better. github.com/jwilm/alacritty/pull/798 is a perfect example.
Lisp dialects are on the lower end of languages that are still alive enough to be useful. It won't die until someone makes a new language that is better at being Lisp than Lisp is, which probably won't happen for decades.

> nah

But nobody talks about F#, even if it seems good