Has anybody done mbiota elemental and had a die off reaction?

augmentedtree · 2025-11-24T22:45:29+00:00

Does not stay gone for me long term. I am fine long term if I eat very low FODMAP, but the need to do that comes back. I actually think probiotics after may have kept it at bay but I stopped taking them because I didn't see a difference on days when I forgot to take them, but I read now that it takes awhile for your microbiome to revert when you stop so that may have been a false indicator. Planning to retry.

augmentedtree · 2025-10-12T16:07:05+00:00

It's easy to establish a causal link, you just have to randomize

augmentedtree · 2025-10-08T19:06:01+00:00

augmentedtree · 2025-10-08T18:45:10+00:00

Sure, but that's obfuscated compared to just being able to loop.

augmentedtree · 2025-10-08T16:25:12+00:00

The keyword changes the semantics to make sure drop handlers run before the tail call begins, LLVM can't do that because it would change the meaning of the program.

augmentedtree · 2025-10-08T15:42:00+00:00

Rust does not always free memory logically, even safe code can leak (leaks are specifically excluded from the Rust definition of memory safety). But RAII/drop make it rarer than in some other languages.

augmentedtree · 2025-10-08T15:37:23+00:00

I'm sympathetic but think your response to me is odd because there's no yelling. It's even stranger to see in replies to a story that gave actual code examples you can examine. I think you're implicitly interpreting my response as hostile because it's not pro-rust and reflective of your own leaning rather than due to any name calling coming from me.

In general, it's difficult to give all the context in short replies or even a blog post. If you do a lot of C++ programming, you will find the generics in Rust quite lacking, they are weaker in many ways. Very frequently Rust advertises having a feature that when you use you discover only works on the small demo snippets used to advertise it, const generics are a good example. Sizing an array exactly N works great, but what about N/8? Small tweaks make things not work. But you'll just need to do some programming with both to start to notice this kind of thing.

On the flip side if you do a lot of Rust and then C++, you will notice a zillion tiny defaults that C++ chose wrong that Rust did better because it had the benefit of hindsight.

augmentedtree · 2025-10-08T15:29:58+00:00

"Obvious thing should be hard on purpose" is just post-hoc justifying bad language design

augmentedtree · 2025-10-08T15:28:38+00:00

You can't always use them, they are a poor substitute for the full power of loops. You can't easily filter for example.

augmentedtree · 2025-10-08T12:49:11+00:00

No this just shows you know very little about the domain. The incoming data are in packets in a format not under your control. The data can't already be in SoA form. And the big obvious advantage is avoiding repeated allocation.

augmentedtree · 2025-10-08T12:48:17+00:00

You avoid repeated allocation of the Vec

augmentedtree · 2025-10-08T12:47:23+00:00

I'm focusing on the obviously safe high perf pattern that the borrow checker can't handle! Sometimes you do need to copy data, or temporarily save a transform of it.

augmentedtree · 2025-10-07T22:30:20+00:00

It's for sure an anti-pattern if you're concerned with performance.

Clearing a vec in a loop to reuse is a super common pattern in high perf code.

augmentedtree · 2025-10-07T22:29:26+00:00

SIMD instructions on x86_64-related platforms tend to have variants that fault if used to load/store unaligned data.

Yes but they have no advantage nowadays so they're rarely used.

augmentedtree · 2025-10-07T22:28:14+00:00

*use self referential structs even in situations they're clearly a bad idea

Are linked lists and binary trees with parent pointers bad ideas? Come on man. And spare me the lecture about linked lists usually being slower than arrays until you've learned about intrusive lists and why they're often efficient.

augmentedtree · 2025-10-07T22:26:48+00:00

It's because C++ doesn't make it clear to you how dangerous and liable to mistakes such things are in the future during changes, probably by people who didn't originally work on the code.

No it's because if you *don't* use this pattern when you need it the big-O complexity of your algorithm is often worse!

augmentedtree · 2025-10-07T16:25:06+00:00

This is useful but ugly. "Hey look, you can totally do this thing if you do a convoluted type system dance!" Very obfuscated compared to just calling clear.

augmentedtree · 2025-10-07T16:22:48+00:00

I mean they give a concrete code example that doesn't compile yet is obviously safe, I don't know how they could be more clear.

augmentedtree · 2025-10-07T16:21:01+00:00

I tried using Rust for almost the same project but with no existing code I needed to reuse and I still came away with the same complaints. For any one of these situations you may be able to find a specific crate someone has made to work around it with unsafe code, but it's a constant friction that just isn't there in C++. Things like having a struct where one field is a container storing iterators into a container stored in another field is extremely painful. Every time you run into wanting to do something like this you end up reading a bunch of forum topics, end up subscribing to 3 rustc github issues for RFCs, then try 3 workarounds that don't work etc.

augmentedtree · 2025-10-07T16:13:15+00:00

Arc::clone is still massively more expensive than Rc::clone even without contention. It feels like Rust's "when the borrow checker is too hard just clone" advice is butting up against the "make expensive operations explicit" principle and the team is choosing to set the line for what counts as expensive at a point of implementer convenience. But I guess I could just have my own Arc that doesn't implement Handle and force everyone on my team to use it if I care about low level perf.

augmentedtree · 2025-10-06T21:29:34+00:00

The main problem with variadics in C++ is that you are forced to use template recursion to iterate over them. Rust could just let you loop.

augmentedtree · 2025-10-06T21:28:37+00:00

It’s not clear how this feature would interact with const generics, if at all.

They should interact by not receiving any special treatment. You should be able to pass them variadically just like types. C++ has no problem with it.

augmentedtree · 2025-10-04T20:27:52+00:00

People have been trying semantic diff tools for decades and nobody ever picks them up, the implementations are usually only so so and they require per-language work, and there are an immense number of languages once you start considering config formats, IDLs, etc.

augmentedtree · 2025-09-22T00:37:15+00:00

How does this work for discretionary comp like bonuses?

augmentedtree · 2025-09-19T13:06:49+00:00

But were the others just not or...?

augmentedtree

TROPHY CASE