tracnar

The unison programming language does foray into a truly distributed programming language: https://www.unison-lang.org/

Ok great, I indeed just tried, I might just have been confused last time! Maybe you could mention in the doc that a module can be a "package"? (Even though I suppose a package is also a module, I always find the Python terminology a bit confusing there.)

When I tried it, it seemed like you really need to list all modules in `tach.toml`.

What I wanted was to work at a coarser package level. For example if you have the modules `foo.a`, `foo.b`, `bar.a`, and `bar.b`, I'd like a rule that `bar` can import from `foo` but not vice versa, without having to list or care about the submodules.

Is that something you'd want to support?

> I agree that "reproducible builds" now means something different, but that isn't exactly the fault of Nix advocates. I guess a new term for "being able to repeat the same build steps with the same inputs" is needed.

I've usually seen "repeatable builds" used for that.

To be clear I did not make CrossHair.

I was also looking into it to turn normal python functions into some kind of constraints. But as you point out in your article it cannot really work through python imperative statements like conditions and loops, so you either need to find a way to cover all code paths, or only use a subset of Python (like Z3 does to some degree I believe). I still need to try it out further.

For your proof assistant it seems you could indeed use it if you limit yourself to Python expressions. Interesting stuff!

This is exactly what the CrossHair library does: https://github.com/pschanely/CrossHair

It also overloads other methods to provide kind of symbolic objects.

I thought it was 2 years warranty across Europe now?

What I've been doing for now is to pre-build the container to include the Nix environment in the nix store. I still run nix in the CI so I only have to rebuild the container from time to time, when the env has changed a lot. It's certainly not an ideal solution but it works without special support.

You indeed need some kind of nix-aware runner (e.g. with a persistent /nix) if you want both the flexibility and performance...

For things in nixpkgs, the files will be mirrored on the nix cache. For your own stuff you could set up your own cache or use a service like cachix. There is also a nix option to set up a generic mirror which looks up files by hash, but I'm not sure if it works with all the ways to fetch things: https://nixos.org/manual/nix/stable/command-ref/conf-file#co...

I wasn't, they look interesting thank you, I'll try it out! Indeed the browser is the most important, even though it would be nice to have something generic for any app.

Looks good! I've been thinking about building something similar but as a desktop app (and maybe browser extension) which would work with whatever text you have on the screen. It seems doable by (ab)using the OS accessibility APIs. I find it hard to stick to importing text, reading them in the app, and marking the words. Having something which works in the background and can tell you where you've previously seen words in different contexts would be ideal for me.

It seems to stem from the Python packaging story being driven by PyPA, rather than the Python foundation, which appears reluctant to pick a packaging solution and ship it with CPython. setuptools was kind of an in-between, it was included in CPython but in many cases you have to update it or add plugins...

It's not yet as far as the Guix stage0, but there was an interesting talk about bootstrapping nix from TinyCC at NixCon: https://media.ccc.de/v/nixcon-2023-34402-bootstrapping-nix-a...

SQL is called relational because it's based on relational algebra [1]. Although in practice it only loosely follows that theory.

[1] https://en.m.wikipedia.org/wiki/Relational_algebra

He later in the post shows invariants which cannot be verified as assertions within the system (e.g. as a process within a distributed application), because they rely on having an omniscient view of the system (e.g. access the state of all processes in the distributed system at one point in time). I think that's where the distinction makes sense. Of course you'll likely still turn those invariants into assertions, but in some kind of simulator which can view the complete state of the system rather than in the system itself.

I'm talking about replacing the battery as a whole, currently there are many form factors and you can't be sure you'll be able to get a new battery when the performance of the original one starts to degrade. If manufacturers would be forced to make it replaceable for X years at reasonable cost, either by providing replacements or by adopting an industry standard, that would fulfill the "right to repair" IMO.

You then want to extend that to the other main parts like the motor or the controllers, so you're not left with a piece of junk when one component fails. Just like for normal bikes.

Standardising the batteries so the connector imposes a certain level of safety would seem like a better solution than making it harder to repair. You can also discourage e.g. self made batteries through insurance policies like you do for cars and homes, i.e. you're not covered if you use a non-certified battery.

He answered that in a comment: https://stgraber.org/2023/08/24/stable-linux-mainline-builds...

The syntax is restricted so the toml content can be extracted without actually parsing the Python file, a regex is enough.

Indeed, on top of stacktraces it would be great to have 'value traces' (with functional programming I suppose those would be the same). Especially in testing, what's important are the inputs with the system under test.

Nice. The GitLab caching API is basically saving and restoring a folder, so if you allow pointing to a local folder instead of the GitHub API you should be good!

I thought that this option solved this problem? https://nixos.org/manual/nix/stable/command-ref/conf-file.ht...

But with the myriad of fetch* functions maybe it only applies to some.

I find Debian-based distros have much more customizations compared to more upstream based distros like Fedora and Arch Linux.

Linux surprisingly allows you to exec a program with argc == 0, so you also want to check for that...

https://lwn.net/Articles/882799/

Having a database separates the view from the model. If you want to modify the generated HTML, it's much easier with the comments being separate from the HTML itself.

I wonder if a type system could track nondeterminism and prevent it. E.g. you couldn't just loop over a set, you'd have to order it, or apply a commutative operation. It would fit well into concurrency too, where nondeterminism is easily introduced.

I'm sure there are languages which do this, I seem to recall seeing it in Mercury

Built over UDP rather than directly over IP. Introducing a new layer 4 protocol on the internet is not realistic for the foreseeable future.

The work on MPTCP started before QUIC. One big difference is that MPTCP puts a lot of effort to look like TCP to avoid being affected by middleboxes (firewall, NAT, proxies, ...). QUIC uses UDP which is more often blocked or throttled, though that will quickly change as it gets more widely deployed!

MPTCP is an extension of TCP and is "drop-in". But AFAIK making it opt-in was a concession to get it upstreamed in Linux, understandably as this is a risky change.

There are different ways to enable it on unmodified applications, e.g. via a wrapper or using eBPF.

Great, curious to see what you discover!