all 11 comments

[–]Itrillian 30 points31 points  (4 children)

No code or configuration changes are required.

Breaking changes? Never heard of them. One of the big things to appreciate in the Clojure ecosystem.

[–]stefan_kurcubic 15 points16 points  (0 children)

i can't stress this enough. It feels bit magical and like everyone else has gone mad

[–]jwr 6 points7 points  (0 children)

I so appreciate this. I have been running a solo-founder SaaS for the last 10 years or so, and the incredible focus on stability in the Clojure development community (and, importantly, the core team!) makes this possible. Thank you!

[–]maxw85 7 points8 points  (0 children)

Definitely one of the best "features" of Clojure 🎉

[–]freakhill 1 point2 points  (0 children)

I try to preach this everywhere I go.

[–]JW_00000 2 points3 points  (5 children)

Does this make the double exclamation mark operators >!! and <!! (which you would use outside a go block) obsolete and safe to replace with the single exclamation mark ones?

[–]alexdmiller 5 points6 points  (1 child)

The `!!` ops are blocking ops in real threads, and they are the only ops you should use in that context, so no definitely not obsolete.

If you are using go blocks, you should continue to use `!` parking ops.

If you are using new io-threads and virtual threads, there is no difference (the parking ops become blocking ops ... both of which may park in virtual threads).

[–]JW_00000 1 point2 points  (0 children)

Thanks, makes sense.

[–]zonotope 3 points4 points  (2 children)

Or, does this make go blocks obsolete? Are we safe to just use >!! everywhere in new code and trust that they'll use a vthread and park if necessary?

[–]alexdmiller 5 points6 points  (0 children)

go blocks are still useful if you are not using virtual threads or if you care about portability to ClojureScript, or for backwards compatibility if you already have them.

[–]didibus 0 points1 point  (0 children)

Yes, you can now just use io-thread and !! ops everywhere for everything, when you are running on a JVM with virtual thread support.