Jesse Noller

Dan, even using english as a first language - I have a difficult time articulating this subject.

1. English

English is the more topic subject dividing engineers and programmer's from reaching their potential. These are people who are already on their path and passionate about growing themselves into programmers.

Can you imagine how we can help them? Their potential if they have localized documentation?

A story of disadvantage - imagine having an issue and being powerless to articulate yourself to a predominately english-speaking world of engineers. What about their hearts, their passions?

And this is effective, safe. Helps people. Constructive. This is great news man.

Now you see where I'm going?

2. The PC troll issue

I feel tempted to blurt out every emotion. But when a particular group is mentioned - we have to make everyone happy? Why is pycon code of conduct pulled off geekfeminism.org (http://jessenoller.com/blog/2012/12/7/the-code-of-conduct). This is sensitivity not to woman, but I feel it's creating a culture of hysteria.

Truly, I do not believe woman in the first world (I'm sorry if this offends people) are at risk of rape or sexual harassment at conferences. Most conferences do not have codes of conduct that state this because it makes you ask, "Why?". Do these people ever go outside, to starbucks, etc? Do they live in a Chapel away from vulgar language and stringent political correctness? I'm deeply sorry to offend anyone here.

But how do you even get to…

I haven't studied it deeply, but a breadcrumb would be that cooperative threads (green threads) are equivalent to coroutines.

Ok it looks like current techniques are stackless runtimes and compiling coroutines to stackless continuations:

https://en.wikipedia.org/wiki/Stackless_Python

https://stackless.readthedocs.io/en/v3.6.4-slp/library/stackless/stackless.html

http://jessenoller.com/blog/2009/02/23/stackless-you-got-your-coroutines-in-my-subroutines

https://engagedscholarship.csuohio.edu/cgi/viewcontent.cgi?referer=&httpsredir=1&article=1346&context=enece_facpub

https://pdfs.semanticscholar.org/b9aa/49e4b7a00e6c9f0d8c18ba9240c1223bc098.pdf

https://www.osnews.com/story/9822/protothreads-extremely-lightweight-stackless-threads-in-c/

This looks like a rare gem, although I just started reading it:

https://cs.indiana.edu/~dfried/dfried/mex.pdf

I grew up with the cooperative multithreading of classic Mac OS and was really shocked when I first saw Javascript back in the 90s and it had no notion of it (because it didn't have generators). That sent us down the callback hell evolutionary dead end, through promises/futures and finally to async/await where we are now. That could have been largely avoided if we had listened to programming language experts!

This ends up needing to be posted in every Stackless discussion:

Stackless DOES NOTHING ABOUT THE GIL! Stackless is not about concurrency. It's about implementing coroutines.

It's a really easy mistake to make. Lots of people think Stackless threadlets look like Erlang processes, but instead, they look more like regular Python generators (although they're admittedly much cooler). To complicate matters, people sometimes actually do use the fact that you can pickle threadlets, send them across the wire, and resume them on another thread/process/machine to implement some form of concurrency, but this does not mean that Stackless gets around the GIL in any way vanilla CPython can't.

To explain more about Stackless, I'll refer you to Jesse Noller's recent post on the subject: http://jessenoller.com/2009/02/23/stackless-you-got-your-coroutines-in-my-subroutines/

Everybody who has ever spoken at PyCon for one (and volunteers as well): http://jessenoller.com/blog/2011/05/25/pycon-everybody-pays

It looks like the OP is an established consultant/teacher, so he probably only goes to conferences that invite him to speak (and my guess is, from what I have heard about you tptacek, that you are in the same boat), so he may be unfamiliar with the practice. But for us peons, with little to no name recognition, conference papers and talks can be a big resume booster, so it's not out of the question to pay-to-speak (you still have to go through the proposal process though). In my old industry, this was standard practice, and because almost everyone had their conference registration and travel paid for by their employer, it wasn't a huge deal.

In Python 2.x there was a module for Berkley DB which is removed in Python 3 (bsddb module). I'm curious that since Berkley DB has always had a strong copyright license and it was not PSFL, how things worked legally. There is no mention in the docs[1] that if you use an import bsddb in your code you have to make it open-source. When they decided to remove it there was no mention of the license, just difficulty of maintenance[2].

So, was it possible to use Berkley DB without releasing your code as open-source before this change or was it because no one thought it was necessary to mention it in the docs?

[1] http://docs.python.org/2/library/bsddb.html
[2] http://jessenoller.com/2008/09/04/stirred-up-dem-bees-should-bsddb-be-removed-from-python/

You are welcome. Actually, the inclusion of your processing module in 2.6/3.0 is an excellent example of a non-core developer getting code into the Python distribution. Your blog postings on the process (especially http://jessenoller.com/2009/01/28/multiprocessing-in-hindsight/) really show how challenging it is to add something to a system that big (and ported to so many platforms). I appreciate the work you've put into processing (and one of these days I'll get around to using it).

Overall, the Python community strikes me as a bunch of really pragmatic, low-key people who have learned the hard lessons in the trenches of software engineering. To me, this is almost more important than the details of the language.