David Beazley

Fck school dude, you good. I mean, unless you like it. My only regret from college is that I spent it studying instead of doing a lot of drugs. If you’re doing computer stuff, the grades don’t mean anything. There are so many paths to get in. You should only stress about the grades if you wanted to go on to be an academic— but if you aren’t enjoying the setting then you probably don’t want to go the academic route anyway.

Here’s the best most beautiful part about coding:

### ain’t no one can stop you ###

You don’t need* a degree to do it. School is not the gatekeeper. The information is yours for the taking.

Check it out: https://www.udacity.com/course/design-of-computer-programs--cs212

You do NOT need to pay money for that course, I know they really try to get you to sign up for a nanodegree but click around till you can take the course.

If you can understand and replicate even 30% of the material in that course you are a certified badass.

Can you load data from a file, manipulate it, and save it to another file? Congrats you are able to get a job with some effort.

If you have an opportunity to take any courses, even the video courses, from Dave Beazley, do it: https://dabeaz.com/ (assuming Python is your thing). You will know more about Python than all of your professors and anyone interviewing you.

Last bit of “stick it to the man” advice, you have one major advantage over more experienced developers that often goes overlooked: the ability to go deep on a…

> Is it to make currently-unsafe Python code automatically correct? Or is it to keep the GIL semantics, but make it faster?

Neither. It's to improve concurrency in the interpreter (there currently is none whatsoever due to the GIL), so that multithreaded software can scale on multiple cores performing Python bytecode execution.

Currently, the GIL means the Python interpreter can only execute Python code in a single OS thread at a time (C extensions such as I/O systems can release the GIL). The result is that, even with a number of (OS) threads spawned in the interpreter, you don't get much parallelism benefits. And even if only one thread performs computation and the rest does I/O, there are churning issues with the GIL (I recommend checking David Beazley's research and presentations on the subject[0]).

[0] http://dabeaz.com/blog.html section "The GIL"

I've taken 2 of David Beazley's courses.[1] And, I highly recommend them. If you haven't seen some of his talks, he's very good at explaining things by building them from nothing.

I took 2 courses: "Rafting Trip" and "Write a Compiler". Both were awesome. The Rafting Trip took us through implementing the Raft consensus algorithm from scratch. And the "Write a Compiler" course had us build a small language using LLVM.

Both courses (but especially the Rafting trip one) were definitely for experienced programmers. In the courses I took, people generally had at least 5 years of professional work. And even still, there were a few people that really struggled to stay on pace in the course.

But at the end, most people had a (kinda) working Raft library or compiler!

[1] https://dabeaz.com/

sweet, I was wondering when someone was going to mention the GIL, now the fun can start.

http://dabeaz.blogspot.com/2012/03/pycon-2012-followup.html

"In any case, the performance of threads is highly specific to the application at hand. You can't just take some benchmark from one of my GIL talks and extrapolate that out to a general statement about all Python thread programming. Personally, I find that Python threads have worked pretty well for most of the problems where I've used them. Of course your mileage might vary."

So.... maybe, it depends on what you are doing.

Personally I would have been happy to see ProcessingActor in pykka, maybe with 0mq for the ipc. That would be cool, but this looks useful nonetheless.

If you're looking for a refresher that outlines Python language fundamentals, I recommend "Introducing Python, 2nd Edition" (2019) by Bill Lubanovic [0].

Another really cool introduction that's filled with intermediate tricks is "Python Distilled" by Dave Beazley [1] (2021).

A couple of nice intermediate books:

"Intuitive Python - Productive Development for Projects that Last" by David Muller [2] (2021).

"Serious Python" by Julien Danjou [3] (2018).

References:

[0]: https://www.oreilly.com/library/view/introducing-python-2nd/9781492051374/

[1]: http://www.dabeaz.com/python-distilled/

[2]: https://pragprog.com/titles/dmpython/intuitive-python/

[3]: https://nostarch.com/seriouspython

David Beazley is a gem.

There are 2 subsequent parts to this one, if anyone's interested, they can be found on the "Tutorials" page:

https://www.dabeaz.com/tutorials.html

Part 1) Generator Tricks for Systems Programmers (what this post links to)

Part 2) A Curious Course on Coroutines and Concurrency

Part 3) Generators: The Final Frontier

Another tutorial I'd recommend -- among my personal favorite -- is "Python 3 Metaprogramming" (also at the URL I included above)

Even if you're not interested in the Python programming language, I'd still recommend having a look at his tutorials and talks; the quality of his work, and especially his delivery, make it all enjoyable.