ijustlovemath

The difference is that these only measure blood sugar, while the new system also measures ketones, of keto diet fame, which are leading indicators of a really dangerous situation called diabetic ketoacidosis. It's treatable with a hospitalized IV insulin drip, but can be avoided if you have some advance notice.

a regulated blood sugar level aids massively in cellular repair, inflammation reduction, and immune response. These are well studied and established. I could absolutely see a top athlete using AID in the future as part of a recovery routine, but I can also understand reluctance to adopt anything new or weird.

non-invasive continuous blood sugar measurement is mired in patents and technical challenges. Turns out it's really difficult to disambiguate the absorption lines of glucose from other similarly shaped molecules when you're also dealing with untangling skin conductivity, transmissivity, sweat, inflammation etc.

Automated glucose control will be the next frontier in so many areas of healthcare. I'm still skeptical that anyone will be able to noninvasively and accurately sense blood sugar, but I'm glad people (especially kids with T1) will have one more tool to help them. I hope they can figure out the reimbursement side to get it into the most hands possible!

I got my first one at age 27. A third just got removed. Living with the constant mole vigilance of that is rough, but I am glad I've learned to identify them. I think knowing the ABCDEs of it should be more widely spread, as removing a mole is a much nicer alternative to having to take margins in a highly mobile place.

Curious what your distribution is, as a ~400 person that thought they did more.

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.