
Channels, Concurrency, Cores: A New Concurrent ML Implementation (2017) [video] - espeed
https://www.youtube.com/watch?v=7IcI6sl5oBc
======
bjoli
Not only that, but guile just got a 2-4x speedup in the 2.9 branch (what will
become guile 3).

It is a really nice scheme implementation and very capable. The stuff the guix
people have done is amazing!

Concurrent ML is my favourite way of writing multi threaded parallel programs.
It is a bliss! One can say that reagents in multidirectional ocaml is another
step downwards in that it in most regards generalises CNL, but in its base
form it is not as simple to work with.

Guile fibers is amazing to work with, and has good repl integration. The
performance I am able to get out of it is nothing short of amazing.

~~~
dman
What are you using it for? Is any of the work publicly available?

~~~
bjoli
I have started using it to do every single task that I would previously use
threads for, and for a lot of other things that I would otherwise have done
sequentially.

Two days ago I made my own very shitty static site generator parallel using
fibers.

I have a POC for a irc-like server with proof-of-work to send messages
depending on current message throughput. (Not online yet)

I am not really a programmer, so I mostly do stupid things with it. I made my
smart home server (written by me, using ZigBee to communicate with devices)
scale to thousands of parallel authenticated connections. Just for fun (or at
least to be able to say that my WiFi and ZigBee dongle gave up before my own
ZigBee controller software did).

I have even used it for fully cooperative multitasking (by setting the "Hz" in
guile-fibers to 0).

------
a-nikolaev
The speaker's article on the topic:
[https://wingolog.org/archives/2017/06/29/a-new-concurrent-
ml](https://wingolog.org/archives/2017/06/29/a-new-concurrent-ml)

------
sctb
Discussions on Andy's related blog posts:

[https://news.ycombinator.com/item?id=14664150](https://news.ycombinator.com/item?id=14664150)

[https://news.ycombinator.com/item?id=17083447](https://news.ycombinator.com/item?id=17083447)

------
jules
How does this compare to Reagents? If I understand correctly, Reagents are the
successor of Concurrent ML.

[http://kcsrk.info/ocaml/multicore/2016/06/11/lock-
free/](http://kcsrk.info/ocaml/multicore/2016/06/11/lock-free/)

~~~
bjoli
Reagents generalise CML, but is also not as opinionated in that it is more a
set of building blocks that can be used in many different ways. It gives you
more flexibility, but at the cost of having to do a bit more yourself.

Reagents are more comparable to STM I would say, even though it is slightly
less expressive in some areas, but on the other hand is always lock-free.

~~~
jules
Apparently I also answered my own question a year ago as a comment on the
associated blog post:

Reagents do generalise CML. The main difference is that CML only allows you to
combine operations with select (op1 OR op2) while Reagents also allow you to
combine operations into a transaction (op1 AND op2 for independent operations
and op1 THEN op2 for dependent ones). Reagents are lightweight in that the
library analyses the combined operation and then figures out an efficient CAS
scheme to execute it. Reagents also include some more low level operations,
such as CAS as a reagent. -- [https://wingolog.org/archives/2017/06/29/a-new-
concurrent-ml...](https://wingolog.org/archives/2017/06/29/a-new-concurrent-
ml#e65f4a9c7419cf15c71a58df4786a1a15f8066e9)

I hope that's correct...

> Reagents are more comparable to STM I would say, even though it is slightly
> less expressive in some areas, but on the other hand is always lock-free.

What is the difference in expressiveness between STM and Reagents? Is it that
STM provides monadic bind, whereas Reagents only provide applicative, i.e.
Reagents cannot dynamically decide to update different locations based on
values read in the transaction?

~~~
bjoli
Well, after having used reagents I have found that for most things so use it
to more or less implement CML anyway. I have never been limited by the CML
way, but I do appreciate the power that reagents give you.

In comparing STM and reagents I will probably just regurgitate what Aaron
Turin says in his paper "Reagents: Expressing and Composing Fine-grained
Concurrency" which you can find using a short Google. I only seem to be able
to copy the Google link, so you will have to Google it yourself.

------
jacinabox
I just want to say that I'm so glad people are developing concurrent
languages. The day that concurrency became of paramount importance to
computing, all of the old languages became obsolete! That's also why we have
Go; goroutines are a major innovation upon threads.

~~~
pjmlp
Modula-2 already had co-routines in 1978.

Concurrent Pascal had them in 1976.

And there are plenty of other examples gaining digital dust.

~~~
bakul
Concurrent pascal didn't allow unsafe concurrent access to shared data
structures. Go _allows_ safe concurrent access but doesn't _stop_ such access.
Its authors encourage people to use channels but this sharing is intrinsic --
one can start a nested function as a concurrent goroutine & it has full
concurrent access to its environment. Go tools can check for race conditions
but ideally such support should be in the language itself. So in a sense Go is
worse than Concurrent Pascal for the main feature it touts!

~~~
teamfrizz
allows and doesn't stop are the same thing.

~~~
kazinator
Maybe OP means "allows safe concurrent access but doesn't stop unsafe
concurrent access".

~~~
espeed
And that capabilities model is one of the big differences in Pony and was the
key to achieving Pony's parallel lock-free _provably correct_ concurrency
model.

Most lang/system capability models (including Go's) are open from the start --
where anyone can do anything -- and then when designing the lang/system you
try to restrict access between some things at some of the time, but this gets
messy fast and it's hard to get right and thus it's almost never optimal.

So rather than trying to start with an open model that's inherently flawed by
definition, Pony flips the model on its head and begins from the perspective
that everything is denied unless specified. You would say Pony has a _deny-
first_ capabilities model, which you can see explicitly defined here in Pony's
capabilities matrix...

[https://soyyomakesgames.wordpress.com/2016/10/10/ponys-
capab...](https://soyyomakesgames.wordpress.com/2016/10/10/ponys-capabilities-
made-simple/)

And if you listen to Sylvan's talks, he is emphatic that solving the
_capabilities problem_ upfront was key that made everything else possible. All
the other cool stuff you hear about in Pony like the provably correct runtime
and finally achieving something approaching Hewitt's elusive Actor model
that's been _theoretically true_ for 40 years but never fully realized. Well
the key to solving that mystery and unlocking the door was to take a new view
on the capabilities model and building everything off that from the start.

