
Offers information on how to exploit the parallel architectures in a computer's GPU to improve code performance, scalability, and resilience.
Something which would be immensely helpful for the community is to create a test suite of pathological problems with existing python concurrency patterns and libraries.
At that point it should just be a matter of time before the right implementation and PEP(s) can be iterated on that solves said problems while maximizing for devex.
For anyone interested in learning more about different concurrency models I can highly recommend Paul Butcher's: Seven Concurrency Models in Seven Weeks.
This is mostly an academic exercise for me personally. I’m not familiar with different concurrency models as I’m starting off in my career and don’t get a whole lot of exposure to it in production. I was inspired by Paul Butcher’s book on seven concurrency models in seven weeks, where we actually does solve problems with different concurrency models in languages that have good support for them. So I thought if I could write down my thoughts and explain it to other people I will have gained some sticky understanding for me.
I think Paul took a year or more in order to research and write his book, and it shows. Conversely it shows how my posts are sort of link aggregations because this series has taken about two months so far. Python’s also not terribly great for CPU-bound concurrency work in Python code.
As to your points, I saw MPI and async await as primitive constructs on top of which you could build something like CSP. Not all software is portable; one example, if you want MKL acceleration in numpy, you have to use Intel CPUs.
The next blog post I’m writing I’m writing about is hardware-based parallelism. IMHO this is Python’s bread and butter, and I should be able to demonstrate how Python comes in handy with code samples.
After ~18 years of Java I was feeling very burnt out. Initially it was the concurrency model and how it was being widely used. This itself drove me to find alternatives.
I started off knowing that Go, Scala, and Clojure (among others) offered cleaner abstractions on this. I figured I'd learn them a little and see where that took me - Seven Concurrency Models in Seven Weeks was the book I first looked at.
It honestly didn't take long, but something with Clojure just clicked with me. Concurrency aside, the REPL experience and immutable data grabbed me and said "Keep learning this language!"
So I took an old game that I'd done in Java (with OpenGL bindings) and started rewriting it in Clojure. Loved the experience and kept working on any problems I could find to try out the functional approaches I was learning.
The punch-line is I fell in love with programming again. I was able to find my passion, to realize again why I went into this field. Slowly turned the career direction and now work full time with Clojure.
https://pragprog.com/book/pb7con/seven-concurrency-models-in...