News for hackers. Stuff that matters.
Re:Ruby's Proposed STM by thaumasiotes on Friday October 30, 2020 @05:00AM (#24940404)
> That’s why C# has that little caveat. You can avoid the pain of async in C# by using threads.

This is the first time I've seen threads referred to as a way to avoid pain.

Re:Ruby's Proposed STM by ancarda on Friday October 30, 2020 @06:21AM (#24940815)
I honestly prefer threads and mutex locks to async/async.

Feel free to burn me at the stake.

Re:Ruby's Proposed STM by tzs on Friday October 30, 2020 @10:38AM (#24942673)
Same here. I'm curious how you got there.

I think a large part of that for me is because early in my career I got involved in Unix kernel work, first writing device drivers and later doing Unix ports, including both porting a swapping Unix to paged hardware (and rewriting pretty much all process and memory management from scratch) and porting a paging Unix to swapping hardware.

That was followed by a few years largely doing embedded stuff on systems too small to have operating systems or memory management units. For those I'd write a small kernel that supported threads and scheduling (sometimes cooperative and sometimes preemptive) and then write the embedded applications much like I would have written them on Unix, using threads instead of processes.

So for me threads are easy and things like async/wait seem overly complicated and less clear because I came at concurrency from the operating system side of things and the hardware side of things (e.g., dealing with interrupts) where thread-like thinking is natural and perhaps required.

Maybe it is conceptually harder for people who come at it from the application side of things?

Re:Ruby's Proposed STM by mumblemumble on Friday October 30, 2020 @03:04PM (#24945693)
I think it's more that threads are a poorer fit for the application side of things.

On the app side, "I want to do this thing that might take a while without blocking the UI, and then do something with the result, and I have zero need to communicate with the code that's running the task beyond giving it its arguments and getting its result back," is the most common use case. Task parallelism is tailor-made for that kind of problem.

Using a dedicated thread, on the other hand, gives you some raw material you can use to solve that problem, but leaves you to handle all the messy details on your own. And doing it the easy way - one short-lived thread for every thing you need to do in the background - is expensive, while doing it the correct way and implementing a thread pool is essentially just committing to Greenspunning your own personal task parallelism library.

Re:Ruby's Proposed STM by formerly_proven on Friday October 30, 2020 @09:00AM (#24941743)
Whether async or threads are preferable depends a lot on context and often the answer will be "both".

E.g. GUI code -> async, because you must do everything on the UI thread. Heavy lifting in a GUI app -> threads. Traditionally you'd do this with a huge mess of callbacks, but these days it's reasonably easy to just write the GUI portion using async and have background computations run in threads signal their results through futures into the async code, which makes everything so much easier.

Re:Ruby's Proposed STM by andrewzah on Friday October 30, 2020 @01:59PM (#24945048)
From what I can tell, both solve different problems.

There are times when one might want async executors like node's event loop or rust's tokio/async-std, but in other situations one might want os threads or "green threads" with a RwLock or Mutex.

What about a few long running threads that use async internally? ;-)

Re:Ruby's Proposed STM by mumblemumble on Friday October 30, 2020 @05:06PM (#24946895)
That's another thing that C# (or, rather, .NET) handles really well. I can't remember the exact syntax, but the Task API has a way of declaring a background task as "long-running". The key difference is, long-running tasks get a dedicated thread; short-running tasks execute on the thread pool.
Re:Ruby's Proposed STM by dullgiulio on Friday October 30, 2020 @03:10PM (#24945733)
That's the Go runtime.
Re:Ruby's Proposed STM by FpUser on Friday October 30, 2020 @10:59AM (#24942909)
Count me in your camp (with the couple of exceptions)
Re:Ruby's Proposed STM by tasogare on Friday October 30, 2020 @09:16AM (#24941889)
They aren’t even solving the same problem. Threads exist to use multiple CPUs while async/await are here not to waste time waiting on I/O.
Re:Ruby's Proposed STM by coder543 on Friday October 30, 2020 @10:07AM (#24942305)
Threads existed long before multi-CPU computers or multi-core CPUs were common, so no... they don’t exist for that reason.

Parallelism and concurrency are orthogonal concerns. Multiple threads can run on the same core, while concurrent awaits can run on separate cores (depending on the language). Or the opposite!

Threads definitely solve wasted time waiting on I/O, but OS-level threads are a very limited resource in many environments, which can cause problems more quickly in programs with unbounded concurrency, and they tend to have a lot of startup cost, so they have to be created judiciously to avoid hurting performance.

Languages like Go and Elixir give the programmer access to unlimited lightweight “threads”, and that works great for concurrency, without requiring developers to re-color their functions.

One additional note is that some OSes (including Linux) have struggled to support true nonblocking File I/O for many years, so you literally have had to use multiple OS threads for I/O concurrency... one for each file operation in progress. Otherwise you would block the async executor! Languages often handle this implementation detail for the programmer, so you just don’t realize you’re using a thread-per-await sometimes.

(io_uring seems to finally solve this in a meaningful way on Linux)

Re:Ruby's Proposed STM by taffer on Friday October 30, 2020 @05:32AM (#24940544)
Threads are fine as long as they do not share mutable data structures. For example, multithreaded application servers are a rather painless experience.
Re:Ruby's Proposed STM by eyelidlessness on Friday October 30, 2020 @10:54AM (#24942850)
Since all of these concurrency approaches’ pain points are around shared mutable state, maybe it’s shared mutable state that’s the pain point.
Re:Ruby's Proposed STM by bglusman on Friday October 30, 2020 @11:37AM (#24943338)
Yup, this is the conclusion of Joe Armstrong and why Erlang/Elixir/BEAM just doesn't allow mutable state, other than process dictionary which is inherently non-shared.
Re:Ruby's Proposed STM by mumblemumble on Friday October 30, 2020 @09:16AM (#24941885)
That observation doesn't really contribute to a comparison of dedicated threads and async/await, though, because the same is true of async routines.
Re:Ruby's Proposed STM by mumblemumble on Friday October 30, 2020 @09:13AM (#24941848)
For a long time I experienced excessive pain with both threads and task parallelism. It took a good year or two to realize the problem was that I didn't have a good instinct for figuring out which technology is more appropriate for a given situation.