David Beazley

Only a happy customer, but if you want an amazing experience building a compiler I highly recommend David Beazley's Compiler Course (or anything else you can sign up for) https://www.dabeaz.com/

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/

Bravo David! David is a clear and insightful presenter of all things Python. His Python Essential Reference is just that, essential. I have six copies, two each of each of the three editions/ Three editions because Python is an evolving language which pays attention both to backwards compatibility and to occasional housecleaning to remove the accumulated cruft. http://www.dabeaz.com/

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…

At my university, I followed David Beazly's talks and tutorials. Just seeing him work and present improved my style and approach manifolds: https://www.dabeaz.com/tutorials.html

David Beazley teaches weeklong intensive courses on Raft and interpreters and SICP. Good use of a corporate education budget. I have no affiliation with it I just love the idea and hope to see more like this. https://www.dabeaz.com/courses.html

And this is a presentation explaining why generators may be extremely useful for all kind of data pipelines: https://www.dabeaz.com/generators/Generators.pdf If you don't know it already, it is really worth looking into. I am a python dev with nearly a decade of experience and I knew generators, and yet this was still an eye opener.

Wow. A now-CC-licensed 4 day (when presented in-person) Python training course that's been iterated on for 16 years! David wrote https://www.dabeaz.com/generators/ which remains one of my all-time favourite Python tutorials. Looking forward to digging into this.

I was lucky enough to take David Beazley's "Rafting Trip," a five-day training course that guides each student through building their own Raft implementation from scratch: https://www.dabeaz.com/raft.html I'd recommend the course to anyone with development experience working with or near distributed systems. David is a fantastic instructor and facilitator, and the blend of student backgrounds led to some great learning and discussion. (I have no financial or personal interest here; I just loved the course.)

+1 to "Effective Python" [1]. It's a great book if you're already familiar with the language, and interested in learning more about Python internals. "Serious Python" [2] and "Python Distilled" [3] are two other good options for intermediate-advanced programmers. [1] https://effectivepython.com/ [2] https://nostarch.com/seriouspython [3] http://www.dabeaz.com/python-distilled/

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/9781492051… [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.

Has anyone taken Compilers course from David Beazley: https://www.dabeaz.com/compiler.html. I'd love to hear your feedback, please

I'm a big fan of David Beazley for getting into advanced features of Python. He's sometimes a little bit, shall we say, oriented towards the experimental as opposed to "use this in production", but regardless he's a great speaker and a very smart dude. In particular I liked this tutorial on Python 3 Metaprogramming: https://www.dabeaz.com/py3meta/index.html

This is still my favorite mind-blowing introduction to them, from 2009: http://www.dabeaz.com/coroutines/Coroutines.pdf Don't have hardware interrupts or threads but still want a multi-tasking operating system? Not A Problem.

This last week I took an in-person class where we covered almost all of the book: https://dabeaz.com/SICP.html The instructor David Beazley very skillfully weeded out all the non-essential parts and added one amazing exercise where we implemented the lambda calculus and, funny enough, the ycombinator. Highly recommend it for anyone who desires to learn this material, can't find the time, and is willing to pay $2500 for the experience.

I would advise against Google's python course, as it is geared toward python devs working at Google. The course teaches Python 2, and goes against widely accepted guidelines such as PEP-8. I highly recommend David Beazley's Python Cookbook (https://www.dabeaz.com/cookbook.html) for the most idiomatic and comprehensive introduction to Python.

As usual, this kind of misses the point. Trampolining for TCO/TCE is fun, but not really worth it. Rather it's cool for concurrency and scheduling, like in Twisted. Dabeatz had a great tutorial in 2009 (using Py 2.5+ - oh my! :-)): http://www.dabeaz.com/coroutines/

Python 2.7 has terrible thrashing in the way the GIL is acquired that is exacerbated as more threads are used. Dave Beazley has given great talks with the technical details: http://www.dabeaz.com/GIL/

Looking at the http://www.dabeaz.com/coroutines/Coroutines.pdf recommended in the article, coroutines remind me of partial functions in Python. Can folks who know more about Python than I do explain when to use coroutines vs partial functions? Is the difference only in the "generator" part of it?

As David Beazley [1] is the goto guy for anything related to python concurrency (His outstanding material on the topic was what finally made python generators / coroutines tick for me). This makes me much intrigued by this! [1] http://www.dabeaz.com/

Reminds me of the classic David Beazley course on coroutines: http://www.dabeaz.com/coroutines/ It highlights a similar pipeline-oriented architecture and eventually ends up being sort of mindblowing.

(Minor nit: the yield-based functions are generator functions, not iterators.) This approach was also described by David Beazley at PyCon, the slides are available at http://www.dabeaz.com/generators/Generators.pdf. He extends this approach to generator multiplexing, coroutines etc., along with useful examples. An excellent read.

I think it's also worth linking to David Beazley's Curious Course on Coroutines and Concurrency [1]. It's exploring the ideas of a task scheduler implemented in Python. This article reminded me of it. It's not a full VM, but about half way into the PDF he goes into quite some detail on how to build a task scheduler modelled after an OS and how it works in an actual OS. Give it a read. [1] http://www.dabeaz.com/coroutines/

If one is interested in exploring more about linking and loading here is an excellent paper on shared libs and dynamic loading: The Inside story on shared libraries and dynamic loading :http://www.dabeaz.com/papers/CiSE/c5090.pdf

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.

The follow-up presentation here is just as good, in my opinion: http://www.dabeaz.com/coroutines/Coroutines.pdf

anybody writing networking-protocol code, embedded systems etc. cannot help but use them. to me it seems that the entire article is pretty narrowly focussed on folks doing web development exclusively. also, fwiw, i think, couroutines are to state-machines as subroutines are to goto. the best tutorial on teh web on this is, imho, by dave-beazley here: http://www.dabeaz.com/coroutines/index.html

The SWIG author in question, Dave Beazley, also gave a couple great talks on the Python GIL: http://www.dabeaz.com/GIL/

> 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"