libxev VS Tornado

It scales to complex examples as well. Retained memory would be handled with its own allocator: for a large data structure like an LRU cache, one would initialize it with a pointer to the allocator, and use that internally to manage the memory.

Blocking (or rather, non-blocking, which is clearly what you meant) IO is a different story. Zig had an async system, but it had problems and got removed a couple point releases ago. There's libxev[0] for evented programs, from Mitchell Hashimoto. It's not mature yet but it offers a good solution to single-threaded concurrency and non-blocking IO.

I don't think Zig is the best choice for multithreaded programs, however, unless they're carefully engineered to share little to no memory (using message passing, for instance). You'd have to take care of locking and atomic ops manually, and unlike memory bugs, Zig doesn't have a lot of built-in support for catching problems with that.

A language with manual memory allocation isn't going to be the language of choice for writing web servers, for pretty obvious reasons. But for an application like squeezing the best performance out of a resource-constrained environment, the tradeoffs start to make sense.

[0]: https://github.com/mitchellh/libxev

io_uring support is obviously great & excellent, fulfills the "high performance" part well.

i was not expecting "Wasm + WASI" support at all. that's very cool. implementation is wasi_poll.zig (https://github.com/mitchellh/libxev/blob/main/src/backend/wa...). not to be unkind, but this makes me wonder very much if WASI is already missing the mark, if polling is the solution offered.

gotta say, this is some very understandable clean code. further enhancing my sense that i really ought be playing with zig.

You might be interested in a pure Zig implementation of these primitives by Mitchell in his libxev library: https://github.com/mitchellh/libxev

https://github.com/mitchellh/libxev

- one from the Tigerbeetle DB

I am not expert in these but I thought Tornado's ioloop was readable enough for me to learn more event loops. Mostly, it was being implemented in pure Python.

https://github.com/tornadoweb/tornado/blob/branch4.5/tornado...

(Had to be in 4.5 because the newer versions 5.x and 6.x, it's switched to Python's stdlib asyncio)

I am a bit confused, Tornado is web server like a apache http server, or a framework like django, or both?

For Python, I use Tornado.

tornado? this https://github.com/tornadoweb/tornado ?

I'm writing a Node app that talks to a server that uses Tornado, a Python networking framework. The server uses WebSocket and structured JSON to expose RPCs, like sign_on called with the following message:

I've been using Python's Tornado (http://www.tornadoweb.org/) for years now.

Now on version 6, it's fast, well maintained, mature, and has good docs with readable code.

@bdarnell has done an excellent job maintaining it.

Here's one example:

Tornado supported async style co-routines before asyncio was a thing. Now it uses asyncio under the hood by default -- and it did so with an exceptionally smooth transition.

Tornado is another micro framework aimed at a specific use case: asynchronous networking applications. Tornado is well-suited for creating services that open a great many network connections and keep them alive that is, anything involving WebSockets or long polling. Moreover, It requires Python 3.5 or higher and drops Python 2 support entirely.

How to fix tornado.util.TimeoutError: Operation timed out after 5 seconds on tornado test debug?