django-async-orm VS FrameworkBenchmarks

I'm not sure if its official. Would love some more guidance/clarity/docs/funding from the django foundation on what it looks like to migrate legacy code to the new ways.

The rednaks repo works great for just giving the new async stuff a go. If everything else is also using async.

I did some experimentation with this. And its a pain trying to migrate a production application that uses gevent and psycogreen2.

The documentation on the code migration path is pretty sparse.

The main hiccup that I ran into was psycogreen2 not being supported.

https://stackoverflow.com/questions/67735453/django-async-or...

https://github.com/rednaks/django-async-orm/discussions/9

In terms of RPS, this web service is more-or-less the fortunes benchmark in the techempower benchmarks, once the data hits the cache: https://www.techempower.com/benchmarks/#section=data-r21

Or, at least, they would be after applying optimizations to them.

In short, both of these would serve more rps than you will likely ever need on even the lowest end virtual machines. The underlying API provider will probably cut you off from querying them before you run out of RPS.

Being pretty fast for a relatively simple user experience is one thing people use it for:

https://www.techempower.com/benchmarks/#section=data-r21&tes...

Sure, Rust and C++ is probably faster when used naively, but I'm sure you'd have a harder time develop stuff in those languages.

Personally I'd probably reach for Rust before touching Java with a ten-foot pole, but people have different preferences for how easy a language should be to pick up, and if you're used to OOP and C-like languages, Java is pretty easy to pick up.

https://www.techempower.com/benchmarks/#section=data-r21&tes...

From https://news.ycombinator.com/item?id=37289579 :

> I haven't checked, but by the end of the day, I doubt eBPF is much slower than select() on a pipe()?

Channels have a per-platform implementation.

- "Patterns of Distributed Systems (2022)" (2023) https://news.ycombinator.com/item?id=36504073

I've only skimmed some of the code, but fwiw, anyone can read their code for each framework that's benchmarked here: https://github.com/TechEmpower/FrameworkBenchmarks/tree/mast...

There's also a good amount of active discussion going on here: https://github.com/TechEmpower/FrameworkBenchmarks/discussio...

Here's the code for the JS (just-js) benchmark: https://github.com/TechEmpower/FrameworkBenchmarks/blob/mast...

And here's the code for the Python Django benchmark: https://github.com/TechEmpower/FrameworkBenchmarks/blob/mast...

Since you mentioned them I think it's worth telling people to take those benchmarks with a larger grain of salt. They've become such a pissing contest that I don't know if they can be called "real-world". There doesn't seem to be much scrutiny of the implementations.

Take some Rust frameworks: they write out pre-computed header strings to the output buffer, completely bypassing what the framework's documentation recommends. Examples are actix[1] and ntex[2]. No one would ever do this in real life.

Now I like Rust, and it'd likely be some of the fastest even without these shenanigans (Axum and may-http don't do that, I believe). But I don't know if other languages/frameworks have benchmarks implemented in the same non-idiomatic way just to look better.

[1] - https://github.com/TechEmpower/FrameworkBenchmarks/blob/mast...

This is a pretty realistic balanced real-world benchmark of web frameworks (and languages): https://www.techempower.com/benchmarks/

It shows that Python with Djang is literally 40 times slower than the fastest framework. Python with uvicorn is 10 times slower.

The use of languages like Python and Ruby literally results in >10x the servers being used; which not only results in higher cost, but also greater electricity use, and pollution and carbon emissions if the grid where the data center uses fossil fuels.

Not to mention, dynamically-typed languages are truly horrible from a code readability point of view. Large code bases are IMO incomprehensible, hard to debug, and more prone to bugs, without static types. I'm aware that Elixir is dynamically-typed, but it (along with JS) is an exception in terms of speed. Most dynamically-typed languages are quite slow. Not only do dynamically-typed languages damage the environment as they're typically an order of magnitude slower, they also lower developer productivity, and damage the robustness and reliability of the software written in it. To be clear, I'm in favor of anything that increases productivity. If Kotlin were 10 times slower, I'd be happy to pay that price, since its genuinely a great language to work with, is statically typed, and developers are more productive in it.

PR link: https://github.com/TechEmpower/FrameworkBenchmarks/pull/8337

It shouldn't be hard to make Zig go to top place then, which is great opportunity to shine, given that they are still missing Zig entries,

https://benchmarksgame-team.pages.debian.net/benchmarksgame/...

https://www.techempower.com/benchmarks/

Clicking around from your link you get to https://doc.powerdns.com/recursor/index.html

> A quad Xeon 3GHz has been measured functioning very well at 400000 real life replayed packets per second.

So that's more like 40 servers. Realistically the complexity of serving DNS is probably somewhere between Fortunes and Json Serialization in the Techempower benchmarks: https://www.techempower.com/benchmarks/#section=data-r21&tes...

So it's possible you could do it with 10, far less than you'd want for proper redundancy.