alex_hirner

Snapshotting programs is also what https://github.com/pydantic/monty enables and aims for.

FWIW, I think we'll see a rise of AI-ready interpreters. In some sense, I like that it challenges traditional microservice architectures as an aside.

I like the CLI interface, very comprehensive.

However, I'm puzzled by pi support: https://github.com/ctxrs/ctx/issues/40

Does ai.backfill() fill incomplete/dirty rows or does pg_durable have some notion of partial completion?

How does it compare to https://github.com/supabase/etl ?

What are your thoughts on eviction, re how easy to add some basic policy?

memray and later a custom request wrapper that output python gc statistics. Our main candidates for the leak are: grpc, asgi server itself, psycopg, django channels. All leaked to some degree. Alas, it did not became clear what caused the runaway leak at 30 MB/s. Capturing flamegraphs just before OOM kills would require some more engineering. Granian contained these situations until upgradings later that year made the system more stable to begin with.

It was and is a life saver. Our django app suffered from runaway memory leaks (quite a story). We were not able to track down the root cause exactly. There are numerous, similar issues with uvicorn or other webservers. Granian contained these problems. Multi process management is also reliable.

I'd love to make it work with flightsql or HTTP endpoints returning arrow IPC [0]! Did you consider using perspective for last-mile charting [1]? Building your own seems like a huge chunk of work. Well done!

[0] https://duckdb.org/docs/stable/clients/wasm/data_ingestion#a... [1] https://github.com/finos/perspective

> The virality of async await is that once you mark a function async, then you can only call it from another async function

That's not exactly true. Many languages return a curried version of it, which can be executed once you have a runtime.

True. Therefore I'm eagerly awaiting an artificially intelligent product manager.

Or I might build that myself.

Looks great! Is flightsql supported over the wire too, so one could hook it up to grafana? Any plans to support iceberg?

We like Rust for its build tooling and safe concurrency primitives. Thus we are eyeballing with candle [1].

OTOH, writing platform specific backends is a huge undertaking. Do you think backends such as MPS may become a shared effort?

[1] https://github.com/huggingface/candle [2] https://github.com/huggingface/candle/issues/313

I think your usage example will be easier to understand, if it explains where nix:0 is setup as CRI image-service. Maybe I glanced over it.

Awesome project!

Any pointer to flakehub?

> schema

I'm dreaming of a universal standard based on JSON Schema. Dynamicity is a challenge of course. I guess one needs to strike a balance between static data, say for each subcommand, and a full blown configuration language, say nix.

> write text datalog queries

you may be interested in https://github.com/sqwishy/owoof

Did you find any limitations of `pico-args` turned into a caveat for tuc?

Does an API similar to vmsplice exist for Windows?

Insert and repeat: https://github.com/01mf02/jaq

Thanks, I'll take your .bzl as inspiration [0]. How did you go about developing against the Starlark API, any IDE support?

[0] https://github.com/harelba/q/blob/master/pyoxidizer.bzl

> two different storage providers in the EU

Which ones did you choose and why?

FWIW, parent rephrased the quoted text in the meantime but without edit history.

> but is too lazy to come up with better ideas

How can you say they are lazy about that?

Exactly.

The observation that a less faulty model is likely less accurate on a noisy validation set than a more faulty model, doesn't change the fact that there must be faulty models with higher accuracy than a perfect model on a noisy validation set.

This one: https://github.com/microsoft/AirSim

My use case is working with motion vectors from its GPU through picam [0]. Is there an alternative?

[0] https://picamera.readthedocs.io/en/release-1.13/api_array.ht...

What was the reason for porting to C#?

Thanks for providing those instructions. What kind of performance do you get for both MobileNet versions?

It maps observations where you have a clue about how they were created (priors) to a stochastic function. So quite literally, you end up with a probabilistic program.

There are many solutions for each prior. Priors can for example be expressed as computational graphs with random variables.

Did any IoT device management service fit the bill too (back then or now)? We are heading towards a similar use case.