tracnar

Nice fix. I wonder if using virtiofs would be more performant: https://virtio-fs.gitlab.io/

pip freeze might not work with platform-specific dependencies, you will only get the platform dependencies from who ran "pip freeze". So you might end up with "linux-only==1.2.3" in your requirements.txt which won't install on windows (or missing windows-specific deps).

poetry should handle this, and you also get hashes for free!

It's a thing with the nix package manager:

https://github.com/clhodapp/nix-runner

A rogue AP could then trick devices into breaking regulations :)

This talk explored a bit that idea, you could have a (full) programming language which is more like SQL so you get good enough datastructures (and indexing- without manual tuning: https://www.youtube.com/watch?v=gC295d3V9gE

I think Prolog (another commenter pointed it out) and datalog do this to some extend.

That's what I expected from the title, use properties of the banana to extract 'random numbers', and provide new bananas to get a pool.

The questions in the article are not too related to 'what are your lives for'. I'd argue that since we made up that question, we are responsible to answer it. So there may be as many answers as there are people (but less, essentially the reason we have religions).

I've been using jurigged [0] for hot code reloading which is great. It works by replacing code objects in place at the function level which naturally handles many cases like applying to existing objects, avoiding loading a module multiple times, etc. As others noted the actual source of this one is not there so it's hard to know what it's doing. The published package contains a binary shared library so I suppose it's written as a CPython extension.

[0] https://github.com/breuleux/jurigged

Doesn't Bazel do exactly that with their Starlark language based on Python?

https://bazel.build/rules/language#mutability

I'm referring to this cryptographic property: https://en.wikipedia.org/wiki/Deniable_authentication

which means that once a message is received you cannot re-authenticate it, so evidence on any device is no better than with unencrypted messaging. This is in contrast with classic public key authentication like PGP which provides further evidence that the message is legit and was indeed sent by who it says.

I think Signal provides deniable authentication, i.e. you can forge messages which cannot be distinguished from a real conversations. I wonder if it has any impact legally speaking, but I guess it would not matter unless there's evidence of tampering.

Podman supports running systemd units inside containers: https://developers.redhat.com/blog/2019/04/24/how-to-run-sys...

One process per container is indeed strange in a lot of use cases, you lose the self-contained advantage of a container...

You could also restrict the allowed XML so it can be parsed/generated without a full parser.

The Tcl wiki is quite strange, it has interesting content but most pages are discussions like this one and it's hard to find what's relevant or even correct.

What's weird about the Tcl syntax is that there is barely any. It's very dynamic so only the top-level of a file is parseable as a list of commands, anything else like a procedure depends on the implementation of the command which can be overridden at any time.

It's even used by built-in commands like expr and if which essentially implement a mini expression language which is different from Tcl.

Ah yes that's cool, they mention even the Python extension can run client-side.

It seems to be like Theia https://theia-ide.org/ which is based on vscode and runs in the browser. It's used by this project to give a full lab/workspace and ide in the cloud:https://www.eclipse.org/che/ (it's actually closer to vscode even though eclipse is in the name).

Pretty much yes, I also switched from Arch and this works great for me.

I only had issues a couple times with broken packages, then you can either not update at all or remove those packages. It should also be possible to keep the older version of those packages in the nix config but I did not look into it.

You can use the unstable branch for rolling releases closer to how arch works.

To me she is referring to what she says previously:

> Also, systems might seem automated but when we pull away the curtain we see large amounts of low paid labour, everything from crowd work categorising data to the never-ending toil of shuffling Amazon boxes.

So the artificial and intelligent part is a tiny piece of the task, most of it is done through humans and logistics.

What's often missing from these discussions is that the trade off in the CAP theorem can change across the system and over time. If you have a cache on your client, you're trading off consistency for availability, same if you do an optimistic update on the client-side. But that does not change the consistency of your database core. You can also "downgrade" to eventual consistency if you detect a network problem.

I feel that a more principled way to navigate between these trade offs and awareness from the application and database of the current consistency guarantees of the data would help to make more robust systems. E.g. you'd want strong consistency by default, with a fallback to strong eventual consistency when the network is poor and the use-case allows it (e.g. not for changing your password, but ok for posting a comment). It needs to be reflected in the UI, and ideally you want the trade off to be decided at each level in a consistent way (client, local database, core database, ...).

AFAIK criu does something like what you describe, similarly to taking VM snapshots but for processes or containers: https://criu.org/Main_Page

Europe imposed a standard for phone chargers and thanks to that you don't need a different charger per brand, or even per model, like it was 15 years ago. AFAIK they did not specify the exact standard, except that it has to be some common industry standard, so it did not prevent moving from micro-USB to USB-C (and whatever Apple is using).

From the article:

> TS It's certainly the case that a lot of CRDTs are really complicated, especially in those instances where they represent some sort of complex interrelated state. A classic example would be the CRDTs used for document editing, string interjection, and that sort of thing. But the vast majority of machine-generated data is of the write-once, delete-never, update-never, append-only variety. That's the type of data yielded by the idempotent transactions that occur when a device measures what something looked like at one particular point in time. It's this element of idempotency in machine-generated data that really lends itself to the use of simplistic CRDTs.

So for this particular use case, the CRDT is simple and they want to favor availability over consistency. I'm not sure if they provide further guarantees, e.g. from the description in the article it seems that temporary holes in the time series would be allowed if updates would arrive out-of-order.

The article also mentions Cassandra, it seems they went for a different design so progress is more quickly visible in the DB (among other reasons I suppose).

> What we wanted was a topology that looked similar to consistent hashing databases like DynamoDB or Riak or Cassandra, but we also wanted to make some minor adjustments, and we wanted all of the data types to be CRDTs [conflict-free replicated data types]. We ended up building a CRDT-exclusive database. That radically changes what is possible, specifically around how you make progress writing to the database.

The art makes the walls look like they have low-quality textures, I was convinced it was 3D renderings at first.

You forgot the one made by Microsoft, Pyright (and PyLance).

Indeed that's what I try to advocate. Of course it's not always easy to know if something should be a hard assertion or not until you hit a failure, which is where I think some framework support to run it in a 'soft-assertion-by-default' way would be handy.

I agree, but the tests are in the order of minutes (sometimes hours), not your typical unit tests. That's basically why it uses soft assertions, it's costly to run. Ideally you'd still want tests with a single assertion/target state, but it's hard to write it that way.

We also do have this conditional test hierarchy, but again it's hard to properly define when the system under test behaves unexpectedly...

We have a test environment with this taken to the extreme at work, i.e. integration tests where the whole codebase softly fails and continues whatever happens. IMO the drawbacks are worse than the upside of seeing more errors. Now one errors ends up giving you a lot of failing soft assertions after the first failure which are not useful at all. There is certainly benefit to being able to go through a failure, but it seems better handled at the framework level rather than writing the tests with this in mind. There's already enough unknown in the tests to add possible earlier failing assertions.

This could go one step further by implementing an import hook, then you could do import users; users.get_all_users(conn)

It's something I've been meaning to try with other languages.

While I would tend to agree, it's now already pretty much phone/touch ready, so it might as well make use of it. I feel like Gnome's UI is finally getting some consistency after having a lot of random changes from version to version in the past years.

I don't really use many of the Gnome apps as I'm mainly in the browser or terminal, but various things like the video player, image viewer, document viewer, recorder, webcam app, process monitor, all seem to have converged to being very narrow focused and simplified. I usually like the simplicity, and if I need more I turn to specialized software.