Armin Ronacher

> the text model of Python 2 is a giant mess and makes it very hard to correctly deal with non-ascii text for any non-trivial software

There are counter-arguments to this. Armin Ronacher, author of (among other software) the excellent Flask web framework, thinks that Python 2's system of codecs and byte streams is better in practice [1][2]. Reasons include: You can do byte -> byte conversions with codecs that are no longer possible. You can better handle text encodings besides UTF-8 (and here he describes several embarassing failures of Python 3 to handle OS paths correctly). You can write single APIs that handle byte streams like gzip and text encodings like UTF-8.

[1]: http://lucumr.pocoo.org/2011/12/7/thoughts-on-python3/
[2]: http://lucumr.pocoo.org/2014/5/12/everything-about-unicode/

The man, the myth, the legend Steve Yegge's blog(s) are worth reading if you haven't yet:

https://sites.google.com/site/steveyegge2/blog-rants

http://steve-yegge.blogspot.com/

Armin Ronacher's blog is also excellent:

http://lucumr.pocoo.org

For the Schemer, or the compiler hacker, Andy Wingo's blog is fantastic

http://wingolog.org

For insights into debugging, kernels, and debugging kernels, Bredan Gregg's blog is fantastic.

http://www.brendangregg.com/blog/index.html

Finally, I wish to list a non-blog: and unblog, or perhaps the remnants of a blog once passed. This is an archive of John Carmack's .plan between 1996, and about 2005.

https://github.com/ESWAT/john-carmack-plan-archive

It is still a fascinating read.

> There are lots of purpose-built bullet proof queuing systems that are simple to setup and administer (or just use SQS).

Because in 99% of cases you don't need a purpose built solution (Even if engineers often think that) at the scale that most people operate in. Nothing is easier to setup and administer than the database you already use.

We are using Postgres as a worker queue in production for many years, with millions of items being processed at any time and it's been perfectly fine. If you have hundreds like in your example...might as well use sqlite.

There's great projects like https://github.com/NikolayS/pgque and https://lucumr.pocoo.org/2026/4/4/absurd-in-production/ that give you even some tooling around that.

Mitsuhiko has written extensively about Py3 unicode problems, e.g. http://lucumr.pocoo.org/2014/5/12/everything-about-unicode/

I think a lot of it boils down to, sometimes you really really don't want to care about unicode. Linux filenames are one thorny issue - Linux thinks of them as strings of bytes, and a tool is broken if it can't also deal with them that way. Py3 makes it very difficult to do that correctly. There are also issues with stdin/out being opened as unicode vs byte streams.

For web development, the "unicode sandwich" (http://nedbatchelder.com/text/unipain.html) works great in my experience. However, I can see his point that for some kinds of tasks, Py3 is unambiguously a downgrade.

Great article, the previous related one goes into a lot more detail on some of pythons different concurrency implementation details: https://lucumr.pocoo.org/2024/11/18/threads-beat-async-await/

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.

I've been writing web apps using Tornado since 2013 and that has been an excellent experience.

But I'm not sure if I have the same opinion of asyncio. To be honest, I don't even know if I understand it completely. There are so many concepts and IMHO they're not really intuitive, so it's difficult to put pieces together and find out how those individual concepts relate to each other or work with each other.

On the surface it looks simple, but it's really like going down a rabbit hole. The more I try to understand it, the more I agree with Armin Ronacher's article on asyncio [1].

[1]: http://lucumr.pocoo.org/2016/10/30/i-dont-understand-asyncio/