Spiritus

I’m curious. Can you explain the problems you were having? And how they would’ve been solved by a static binary.

> Trying to load source files from all over the filesystem at runtime is hell.

This sounds like a mess unrelated to Python. Why are you trying to load source files from "all over the filesystem" at runtime?

> I would love to see a move towards "static" binaries that package everything together into a single, self-contained unit.

Compiling source files from all over the filesystem would be equally annoying.

Answering my own question:

> TPR-3 is a composite hardware environment score for a three-machine configuration, derived from all test types for TPR-tagged <T> frameworks. (More about TPR frameworks and TPR-1 versus TPR-3)[1]

[1] https://github.com/TechEmpower/FrameworkBenchmarks/wiki/Tech...

What does the new "<T>" icon represent on the graphs (only present on some of the frameworks)?

Rocket will compile on stable when Rust 1.45 is released in July. Of course it requires a new release of Rocket as well (v0.5?).

https://github.com/SergioBenitez/Rocket/issues/19#issuecomme...

Or use kubens[1].

[1] https://github.com/ahmetb/kubectx#kubens1

Apparently it does support Linux as well. At least according to some of other comments here.

What are you talking about? What do you think SQLAlchemy uses as a Postgres driver?

Sure, there's some alternatives. But 99% use psycopg2.

Try `brew install gh` instead, it's part of homebrew/core.

>`gh` isn't part of homebrew/core yet as it's very new. So we'll be adding it in the coming months

It's been part of homebrew/core for something like two weeks: https://github.com/Homebrew/homebrew-core/blob/master/Formul...

What does FastAPI actually add on top of Starlette which it’s built upon?

Basically “much less than”.

Interesting. Do you know how Apexcharts.js performs with real-time graphs? We're currently using Chart.js via react-chartjs-2 and while it works, it's consuming quite a bit of CPU.

Maybe just me, but I feel this thread is just validating everything he’s saying. Literally every comment is an explanation/excuse why you should use Rust or why Rust is better at literally everything.

Disclaimer: I’ve had a “few” beers so I might talking with my ass, but damn...

Wipr: https://giorgiocalderolla.com/wipr.html

Do you have plans to add support for more languages besides JavaScript and Rust down the line, e.g. Python?

Surprising how? I've used most of the "batteries" you mentioned in the past year.

You might be interest in Redis Streams[1], it's basically Kafka in Redis.

[1] https://redis.io/topics/streams-intro

See https://www.redhat.com/en/blog/introducing-red-hat-universal...

>Channels was supposed to make core but never did - what happened there?

https://www.djangoproject.com/weblog/2016/sep/09/channels-ad...

No problem. I do it every day.

I'm using https://www.tilaa.com/en which is based in the Netherlands.

This is "stolen" from r/rust. But there's also a `scan!` macro in serde_scan[1]

    let line = "#1 @ 555,891: 18x12";
    let parsed = scan!("#{} @ {},{}: {}x{}" <- line)?;

[1] https://docs.rs/serde_scan/0.3.2/serde_scan/macro.scan.html

>So you're going to periodically make maintenance changes to my system without my permission. Goodie.

I suspect this is partly because the cache can consume a huge amount of disk space over time and many users might never run `brew cleanup` or doesn't even know about it. And then wonder where all their disk space has gone.

If I had to guess. Probably to prevent tainting the base system.

Not sure about interactive functionality. But it basically means it provides ready-made React components.

I don't. Can you provide an example or two?

That's nice and all. But then you have abominations like this:

    state
        .db
        .send(Queries::GetTopTenHottestYears)
        .from_err()
        .and_then(move |res| {
            result.push(res.unwrap());
            state
                .db
                .send(Queries::GetTopTenColdestYears)
                .from_err()
                .and_then(move |res| {
                    result.push(res.unwrap());
                    state
                        .db
                        .send(Queries::GetTopTenHottestMonths)
                        .from_err()
                        .and_then(move |res| {
                            result.push(res.unwrap());
                            state
                                .db
                                .send(Queries::GetTopTenColdestMonths)
                                .from_err()
                                .and_then(move |res| {
                                    result.push(res.unwrap());
                                    fut_ok(result)
                                })
                        })
                })
        })
        .and_then(|res| Ok(HttpResponse::Ok().json(res)))
        .responder()

https://github.com/actix/examples/blob/master/async_db/src/m...

My suspicion is the people do this to avoid "variable does not live long enough" type errors.

The file is in a different location depending on OS. For example on macOS it’s ~/Library/Preferences/kitty/kitty.conf

What's the deal with the `while ... while(0)` and `do ... while(0)` macros? Is it some scoping trick?

    #define TKVDB_EXEC(FUNC)           \
    do {                               \
        TKVDB_RES r = FUNC;            \
        if (r != TKVDB_OK) {           \
            return r;                  \
        }                              \
    } while (0)

    #define TKVDB_SKIP_RNODES(NODE)    \
    while (NODE->c.replaced_by) {      \
        NODE = NODE->c.replaced_by;    \
    } while (0)