ijustlovemath

Why does Rust feel like a bad choice to you? In my experience shipping med device software, it's great for keeping the code that teams write cohesive and correct

editions could be self-describing as to certain semantic changes, and you could embed that with the file. older versions could safely ignore it and newer versions parse and run it. you could also force things like "editions must be declared early", "editions are one way only" etc to get some level of security in the adoption of the change

Helene survivor here. I will be spreading the word about this project and keeping some APKs for if the shit hits the fan again. FDroid being able to sync between local devices means all you need is to get fdroid onto someones phone. Wish they had an iphone app though!

To be clear, all of that setup happens once on your host machine, then you never have to think about it again! You can compose to your heart's content. I think podman just doesn't want to commit to a particular DNS solution so they leave that decision to you.

I had to do some extra stuff for my containers, here's some info from a tutorial I wrote:

Following the Arch wiki:

# Dependencies `yay -S podman slirp4netns aardvark-dns`

# Setup podman-compose and the venv ``` python -m venv .venv source .venv/bin/activate pip3 install --user podman-compose ```

On WSL, you'll need to be on Debian bookworm or newer. Older versions of podman-compose for, ie, bullseye, do not work.

# Reserving alternate UIDs/GIDs `# usermod --add-subuids 100000-165535 --add-subgids 100000-165535 username`

# Setup the storage configuration to overlay Create/edit the following file: `vim ~/.config/containers/storage.conf`

Add/edit the following line: ``` [storage] driver="overlay" ```

# Propagate changes to podman `$ podman system migrate`

# Bring the systems up `podman-compose up`

# I'm on WSL and it's not working (DNS issues)

Check if the network created by podman has dns enabled:

``` % podman network inspect $containername_default | grep dns "dns_enabled": true, ```

If it's false, install another dns resolver:

``` sudo apt install golang-github-containernetworking-plugin-dnsname ```

Then delete the network created by podman-compose:

`podman network rm $containername_default`

## Out of memory when running `podman-compose up`

This error may include "could not map anonymous shared memory".

If you're on a mac, try increasing the amount of memory the VM can use, eg:

https://stackoverflow.com/questions/70114200/increase-podman...

``` podman machine stop podman machine set --memory 4096 podman machine start ```

This will provide podman with 4GB of memory to work with when spawning containers.

https://gist.github.com/ijustlovemath/82b4fa31a7c745e87bac5f...

what kind of stuff is in your compose?

We made a very functional job queue in Postgres with PostgREST. highly recommend, as the automatic REST API makes building new clients a breeze

Probably with Special Window Settings (right click top bar of your mpv window)

Traits, Enums, and Typestate allow much richer paradigms at much lower cost

is it working though? The main outcome we've seen with companies that drink the AI Kool aid en masse is buggy unstable systems. clearly there's a level of rigor that's being missed for ship velocity

When you write Rust long enough you settle on certain architectures (message passing, event loops) that go well with the borrow checker, and don't end up thinking about it too much. Plus you can always throw an agent at the first set of errors from the refactor and let the compiler guide the annoying parts.

It seems like the problem in this application is that attention itself. Makes me wonder if using a transformer for transcription is the correct architecture.

While not an RF book per se, High Speed Digital design does a great job of spanning the gap from EE undergrad to the basics of RF as it relates to digital design. I'd also recommend brushing up on more advanced E&M, eg T{E,M} modes and antenna design if you haven't looked at them in a while

No mention of how he was essentially homeless and collabed his way thru thousands of papers? Or the whole "You have set mathematics back a month" episode?

Absolute legend!

During the Paleocene-Eocene Thermal Maximum, the rate of change of CO2 concentration was 1/4 what we're at today

JWT operates on a different principle; the user's private key (API key) never leaves the user's device. Instead, the stated "role" and other JSON data are signed with the servers pubkey, then verified by the server using its master key, granting the permissions that role allows.

1 exabyte/month is 380GB/s, which would be pretty epic in my opinion!

Even the most complex distributed systems can be understood with the context windows we have. Short of 1M+ loc, and even then you could use documentation to get a more succinct view of the whole thing.

how about ansible?

There's no actual source for this, just some examples

I wonder how well local inference would work on these.

I think it's safe to assume given recent storms that the 1% floodplains are _underestimating_ the risk

The price of the carried inventory is still significant; the scale they mention reaching towards is thousands per day. That's not including the backlog of components they would have onsite to ensure production uptime.

My point is that we really don't know what "plausible" is anymore with these storms. That much is clear in the data. It seems silly to be so close to a flood zone with your very expensive DUV/EUV machines. There are probably other places they could have placed this facility.

Helene survivor here. What's wild to me is that, regardless of the small scale of this facility, it's only a few hundred meters from a 1% flood zone: https://msc.fema.gov/portal/search

The address I found for the facility is 9101 Windmill Park Lane Hudson, TX 77064

This seems ill advised given recent events like Hurricane Harvey

Indeed, the connection to Stokes here is via the fact that both operators (abstracted derivative and antiderivative) are linear operators.

Huh, never thought about the potential connection between the set-containment operation and Stokes like that.

How would this product compare to a PostgREST based approach (this is the cool tech behind the original supabase) with load balancing at the HTTP level?

True, and they do indeed offer an additional layer of protection (but with some nontrivial costs). All (non-business killing) avenues should be used in pursuit of defense in depth when it comes to sandboxing. You could even throw a flatpak or firejail in, but that starts to degrade performance in noticeable ways (though I've found it's nice to strive for this in your CI).

Nowadays, it's fairly simple to ask for a unit file and accompanying bash script/tests for correctness. I think the barrier in that sense has practically vanished.