Clojure

>Clojure

Is it worth learning it?

Attached: Clojure_logo.svg.png (1200x1200, 89K)

Other urls found in this thread:

youtube.com/watch?v=P76Vbsk_3J0
youtube.com/watch?v=wASCH_gPnDw
youtube.com/watch?v=cPNkH-7PRTk
youtube.com/watch?v=34_L7t7fD_U
youtube.com/watch?v=ROor6_NGIWU
github.com/clojure/clojurescript
news.ycombinator.com/item?id=19728502
youtube.com/watch?v=av9Xi6CNqq4
twitter.com/SFWRedditImages

No, learn haskell instead

No, learn Scala instead.
What's it like being a fat irrelevant and unemployed traploving desktop ricing weebfaggot who never gets shit done?

The absolute state of Scala programmers.

Watch Rich Hickey's talks, they're good
If you're turned on by the concepts he discusses, give Clojure a shot
However, don't bother with Datomic

Yes. It's fun, useful, and concise.
Widely supported on all editors and IDEs
Leans on the JVM
Can leverage the Java ecosystem while saving you the need to write in Java.
Also what said, although the concept of Datomic is cool. I wish they'd open source it.

Some recommended Rich Hickey talks:
Clojure for Java Programmers - youtube.com/watch?v=P76Vbsk_3J0
Expert to Expert: Rich Hickey and Brian Beckman - Inside Clojure - youtube.com/watch?v=wASCH_gPnDw
Clojure for Lisp Programmers - youtube.com/watch?v=cPNkH-7PRTk
Simple made easy - youtube.com/watch?v=34_L7t7fD_U
The language of the system - youtube.com/watch?v=ROor6_NGIWU

The last two are my favourites.
Also like a lot of the ideas in Spec-ulation but it isn't quite as refined as those two.

Spec-ulation and Maybe Not are for people already into clojure imo, so I didn't include them in the list.
It's enjoyable to see someone who has such a deep understanding of the topics he's talking about. pretty insightful.

Thanks, I saw one of them and got interested. I'm not the most experienced programmer and use Java and Python untill now. Wanted to learn JavaScript next to get some FrontEnd Skills, but now that I read abt ClojureScript aswell I'm intrigued to learn it.

Beware user, I'll sing clojure's praises until tomorrow but cljs is a bit of abandonware afaik

it's not, the maintainer is actively using it in an application he's building himself (It's david nolen, he's working on an addon for browsers/android/iOS/etc. that will use biometrics instead of the passwords; pretty neat once it will allow third party devices)

Why are you so triggered by Haskell? It won't open you as much job opportunities, but it's a great language. When do you guys became so practical and mercantile?

Attached: kot.jpg (3024x4032, 1.15M)

>cljs is abandonware
github.com/clojure/clojurescript
last commit: 2 days ago

frankly I'd rather have my password stolen than my thumb

>most of [Walmart's] mission critical services are written in Clojure.
news.ycombinator.com/item?id=19728502

>afaik
Thanks for the correction anons

It is not bad for what it is, but consider that it's a Lisp/Scheme family language.

These really have very little to show for after 60y+ of existing and getting promoted by academia (yea, FP is a logical idea, but Lisps evidently suck).

Bad debugger, slow start up, big use memory.
But decent fast,lisp with massive libs, easy concurrency, minimal and beautiful syntax.

But if you use Java Kotlin is probable more profitable language.

I'm really offended by them using Component
youtube.com/watch?v=av9Xi6CNqq4
Nice dubs but Clojure added quite a lot, didn't let itself get held down by the traditions of older lisps. While lisps provide only first class support for lists, Clojure also provides first class support for vectors, maps, and sets. Clojure also has concurrency semantics, separation of symbols and vars, arbitrary dispatch polymorphism (why be polymorphic only on input type?).
The data types support also translates to all data manipulation functions.
(into () ... ) , (into [] ...), (into {} ...), (into #{} ...)

the old cons, car and cdr have been abstracted to conj, first, rest
It has destructuring.
All in all, it's the most futuristic lisp
>Bad debugger,
Which IDE are you using? I only had good experience with CIDER
>slow start up, big use memory
Ain't the JVM grand? Have you tried GraalVM?

What don't you like about Component?

> bad debugger
I've heard my coworker complaining about that too, but I just don't understand the issue; I never missed anything with the emacs' one.
I'd rather mention the obscure error messages, in the sense that it sometimes just limits itself to throw up a java stacktrace - which might be limiting for some people. But idgaf, I know java and it works for me.

I agree on the other points, though, shit's slow to start and I'd never use it for stuff like system scripting purposes.

Component sucks massive dicks, it doesn't scale well and it requires a centralized register of dependencies somewhere in your main namespace - which is the job that should be done by the namespaces themselves. Mount is 100x better.

Not a lisp weenie, but there's little LISPs cannot do. They just got a fame of the languages that are easy to implement and end up never being used, but they're actually quite powerful. They're a real joy to use.

No, learn Racket instead

Attached: serveimage.png (591x768, 65K)

Component is clumsy and ugly, forces you to work with records, creates state which is hard to debug, even slower to start up, permeates the entire codebase, and gives you the same brain rot OO gives, which is what I'm trying to stay away from.

Clojure was my gateway drug from Ruby to based Haskell, I recommend getting into functional programming whatever way you can.

>haskell

Attached: haskellets.png (907x814, 265K)

> being this mad at an objectively superior language

as a js webbrainlet i had a lot of trouble trying to understanding clojure. seriously fucked up my self esteem. ill try learning it again eventually, but surely there's something i'm missing?
even simple examples had me at a complete loss.

How is Rust so based?

Attached: 7F51D8B9-33DE-4F3E-AC4F-93F23290C789.jpg (1280x720, 110K)

Attached: cover.png (800x400, 141K)

Have you written enough Clojure and Haskell to judge which one is more productive for you?

Did you read a book? If not, you must read a book.

Most FP languages aren't worth it.
If you can't look at a language and say "Holy shit that solves X problem I've been having!!!!!!!!!!", and that problem is actually important, there's no fucking reason to learn a new language.
It's a huge time investment but most FP languages have 0 job openings near me, so it's like a useless talent (apart from getting hipster points)

because basedboys

>Most FP languages aren't worth it.
they might not be worth it for you because there's 0 job openings near you, but most of them solve an extremely important problem, which is to limit pajeets from doing stupid shit, which results in very high code correctness in projects as a byproduct.

this is the kind of insight you can find only on Jow Forums

Who would've though that you have to work hard in order to learn something.

Attached: Screenshot_Tachiyomi_20190516-135250-01.jpg (646x1548, 470K)

I appreciate the cleverness of LISPs. Being able to "build your own language for every problem" sounds like a great thing.

But the reality is its not maintainable. You can't just sit down in front of a random selection of LISP code and know what its doing. You have to spend time digesting all of the macros and other trickery.

If you are a solo or small team, this can be managed. But once you scale to larger groups of people this becomes a constant drain on productivity that you can never get rid of. Maintaining that code will always be painful, and you make that commitment at the very start. Guaranteed technical debt.

Largely I think this is why functional programming hasn't panned out. The overhead is not worth the beauty that you get. You can't just look at programming with an isolated academic idealism. You have to consider the real world impact of the choices you make in technology.

Lisp is great to hack around with on personal projects. And it seems to have worked out great for EMACs.

But can you imagine the sprawling mazes of spaghetti you will get if you throw this shit at Pajeets? Gives me nightmares just to think about.

>language that no one uses
no

>Guaranteed technical debt
Every line you ever write is guaranteed technical debt, especially in a growing company.
You give really good argument to keeping teams and projects small. I've seen some terrible, monolithic and ugly clojure code, and still you can figure most of it out in a day, unless it hides some hideous hacks (which off course the project I work on has aplenty)

> I'm not using, therefore no one does
(You)
Any companies' one-man project's code sucks, unless that man is john-carmack-level of sociopath (and mostly he's not). You're talking like that about lisp because it's something everyone in the industry says, but I can assure you that if I had to sit down to fix the code that was written by my ex-colleague who left a year ago - I'd pretty much ace it in a day or two, depending on the gravity of the bug. Clojure has python levels of readability.

Racket is faster than I thought. Also, JS is a good surprise.

No, write all your code in machine code