Live data from Hacker News

Rob Pike – 'Concurrency Is Not Parallelism' [video] (2012)

vimeo.com

41–45 of 45 posts

Re: Rob Pike – 'Concurrency Is Not Parallelism' [video] (2012)

#41
post #23

It seems like we forgot about lightweight fibers for about 30 years and then collectively rediscovered it in about 2010. sure, Java did green threads, but not like m:n stuff. I sometimes wonder where we would be now if people would have gone "Wow, mr Reppy! concurrentML is so cool!" in 1993. instead we got pthreads and collective amnesia and later we got go's girly times and channels which are only half way there.

"girly times" = goroutines?

yep. writing on my phone. notoriously bad at proof reading.

Re: Rob Pike – 'Concurrency Is Not Parallelism' [video] (2012)

#42
post #23

It seems like we forgot about lightweight fibers for about 30 years and then collectively rediscovered it in about 2010. sure, Java did green threads, but not like m:n stuff. I sometimes wonder where we would be now if people would have gone "Wow, mr Reppy! concurrentML is so cool!" in 1993. instead we got pthreads and collective amnesia and later we got go's girly times and channels which are only half way there.

That's because they are very rarely useful. This was true then and it's still true now. There's just not many workloads where it makes sense to need to rapidly launch a thread that doesn't need to do much of anything but does need to exist for a while before terminating. What is useful is the state machine aspects of things like coroutines or async/await, but those aren't quite fibers and very much aren't M:N threadi…

you can implent something like futures on top of cml and use it as async. then you get async for stuff where async is useful and a proper way to write parallel programs for when async would lead to all the bad stuff async leads to.

i rarely write gui stuff and I find async is rarely what I need. in f# I at least have the option to use hopac.

Re: Rob Pike – 'Concurrency Is Not Parallelism' [video] (2012)

#43
post #31

Concurrency is a programming abstraction that conceptually allows multiple independent processes to run at the same time using scheduling. For example, running ten programs at once with only a single CPU. Concurrency is effectively CPU scheduling with maybe some other concepts of communication between processes for coordination. Parallelism is running processes at the same time. The driving motivation behind concurre…

Concurrency is like "con man". That's how I remember it. https://www.bigbinary.com/blog/gvl-in-ruby-and-its-impact-in...

Re: Rob Pike – 'Concurrency Is Not Parallelism' [video] (2012)

#44
post #42

Earlier quoted context omitted.

That's because they are very rarely useful. This was true then and it's still true now. There's just not many workloads where it makes sense to need to rapidly launch a thread that doesn't need to do much of anything but does need to exist for a while before terminating. What is useful is the state machine aspects of things like coroutines or async/await, but those aren't quite fibers and very much aren't M:N threadi…

you can implent something like futures on top of cml and use it as async. then you get async for stuff where async is useful and a proper way to write parallel programs for when async would lead to all the bad stuff async leads to. i rarely write gui stuff and I find async is rarely what I need. in f# I at least have the option to use hopac.

> and a proper way to write parallel programs for when async would lead to all the bad stuff async leads to.

you need real threads for parallelism though? And real threads scale just fine such that m:n threading isn't typically needed.

Re: Rob Pike – 'Concurrency Is Not Parallelism' [video] (2012)

#45
post #42

Earlier quoted context omitted.

you can implent something like futures on top of cml and use it as async. then you get async for stuff where async is useful and a proper way to write parallel programs for when async would lead to all the bad stuff async leads to. i rarely write gui stuff and I find async is rarely what I need. in f# I at least have the option to use hopac.

> and a proper way to write parallel programs for when async would lead to all the bad stuff async leads to. you need real threads for parallelism though? And real threads scale just fine such that m:n threading isn't typically needed.

that is one of the reasons async is everywhere. proper threads are not enough. 2 threads are great at doing 2 things at once, but unless you have the hardware 1000 threads scale very badly at doing 1000 dings at once.

with CAS, making a multicore cml is not too hard.

Post reply on HN